Tabular data 기반의 예측(분류)

데이터 불러오기

 data frame으로 불러오려면 pandas를 써야 함.

import pandas as pd

 

csv를 읽으려면 pd.read_csv

df = pd.read_csv(csv_path)

 

 

데이터 분석

1. 데이터 불균형 판단을 위한 개수 비교

df['column_name'].value_counts()

 

그래프로 확인

import seaborn as sns

import matplotlib.pyplot as plt

sns.countplot(data=df, x='column_name')

 

2. 수치형 column간 상관 관계 검토

corr = df.select_dtypes('number').corr()

sns.heatmap(corr , annot=True)

 

3. 불균형 데이터 보정을 위한 over sampling

from imblearn.over_sampling import SMOTE

smote = SMOTE(random_state=0)

X_train_over, y_train_over = smote.fit_resample(X_train, y_train)

 

데이터 정리

1. 불필요한 컬럼 삭제 : drop (inplace로 할지 여부는 상황에 따라 판단)

df.drop(column_name 또는 column_name의 list, axis=1, inplace=True)

 

2. 특정 컬럼값이 지정 된 조건에 해당하는 행 삭제

df3= df[df['이름'] == 'SW']

 삭제 대신 조건에 맞는 index를 얻어내서 그 반대값을 취하는 방법

# Boolean Indexing

cond = (df['column_name'] 조건)

df = df[~cond]

 

3. object 형으로 되어 있는 수치형 컬럼의 타입 변경

df['column_name'] = df[' column_name '].astype('float')

 

4. null 삭제 혹은 채우기

- 컬럼별 null 개수 확인 :

df.isnull().sum()

 . null이 너무 많은 컬럼은 drop 시킨다.

- null이 포함 된 행 제거

df.dropna(inplace=True)

 

5. 범주형 데이터를 one-hot encoding

cal_cols = df.select_dtypes('object').columns.values

df = pd.get_dummies(data=df, columns=cal_cols, drop_first=True)

 

 

 

 

학습 데이터 처리

1. 데이터 정규화

 - 학습 및 테스트 데이터의 소스가 같다면 먼저 정규화를 한 후 나눠도 좋을 것 같다.

# StandardScaler 수행

from sklearn.preprocessing import StandardScaler

ss = StandardScaler()

X_norm = ss.fit_transform(X_source)

 - 만약, 학습/테스트 분리 되었다면, 학습 데이터로 정규화하고, fitting 된 상태로 테스트 데이터도 정규화

X_train = ss.fit_transform(X_train)

X_test = ss.transform(X_test)

 

2. Feature/ Output 분리

- 하나의 dataframe에 있다면, output column을 포함/제외 하는 방식으로 쉽게 분리 할 수 있다. inplace 하지 않도록 주의!

X = df.drop('output', axis=1)

y = df['output ']

 

3. Train/ Test 데이터 분리

- sklearn으로 쉽게 분리

- output 비율도 맞추기 위해 stratify를 y로 설정 <-- 분류 문제인 경우, 분류하고자 하는 종류에 대해 골고루 테스트

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, stratify=y, random_state=42)

 

 

 

 

학습

성능평가 라이브러리

from sklearn.metrics import confusion_matrix

from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score

from sklearn.metrics import classification_report

알려진 머신러닝 모델

https://scikit-learn.org/stable/supervised_learning.html

1. Supervised learning

 

1.LogisticRegression

from sklearn.linear_model import LogisticRegression

lg = LogisticRegression()

lg.fit(X_train, y_train)

lg_pred = lg.predict(X_test)

accuracy_score(y_test, lg_pred)

 

2.KNN (K-Nearest Neighbor)

from sklearn.neighbors import KNeighborsClassifier

knn = KNeighborsClassifier(n_neighbors=5)

knn.fit(X_train, y_train)

knn_pred = knn.predict(X_test)

accuracy_score(y_test, knn_pred)

 

3. 결정트리(DecisionTree)

from sklearn.tree import DecisionTreeClassifier

dt = DecisionTreeClassifier()

dt.fit(X_train, y_train)

dt_pred = dt.predict(X_test)

accuracy_score(y_test, dt_pred)

 

4.랜덤포레스트(RandomForest)

from sklearn.ensemble import RandomForestClassifier

rfc = RandomForestClassifier()

rfc.fit(X_train, y_train)

rfc_pred = rfc.predict(X_test)

accuracy_score(y_test, rfc_pred)

 

5.XGBoost

from xgboost import XGBClassifier

xgb = XGBClassifier()

xgb.fit(X_train, y_train)

xgb_pred = xgb.predict(X_test)

accuracy_score(y_test, xgb_pred)

 

6.LGBM

from lightgbm import LGBMClassifier

lgbm = LGBMClassifier()

lgbm.fit(X_train, y_train)

lgbm_pred = lgbm.predict(X_test)

accuracy_score(y_test, lgbm_pred)

 

 

딥러닝

1. 필요한 라이브러리

# 딥러닝 라이브러리 임포트

import tensorflow as tf

from tensorflow.keras.models import Sequential, load_model

from tensorflow.keras.layers import Dense, Dropout, BatchNormalization

from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint

tf.random.set_seed(100)

 

2. Sequential

model = Sequential()

model.add(Dense(32, activation='relu', input_shape=(X_train.shape[-1], )))

model.add(BatchNormalization())

model.add(Dense(16, activation='relu'))

model.add(Dropout(0.5))

model.add(Dense(1, activation='sigmoid'))

#model.summary()

 

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

 

early_stop = EarlyStopping(monitor='val_loss', verbose=1, patience=5)

check_point = ModelCheckpoint('best_model.keras', verbose=1, monitor='val_loss', save_best_only=True)

 

history = model.fit(X_train, y_train, epochs=50 , batch_size=16, validation_data=(X_test, y_test), callbacks=[early_stop, check_point])

 

best_model = load_model('best_model.keras')

 

pred_best_model = best_model.predict(X_test)

pred_result = []

for pred in pred_best_model:

  if pred > 0.5 :

    pred_result.append(1)

  else :

    pred_result.append(0)

print( accuracy_score(y_test, pred_result) )

print( recall_score(y_test, pred_result) )

 

Over-sampling 된 모델의 학습

model = Sequential()

model.add(Dense(64, activation='relu', input_shape=(X_train.shape[-1],)))

model.add(Dropout(0.3))

model.add(Dense(32, activation='relu'))

model.add(Dropout(0.3))

model.add(Dense(16, activation='relu'))

model.add(Dropout(0.3))

model.add(Dense(2, activation='softmax'))

# 모델 컴파일

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

# 조기종료

early_stop = EarlyStopping(monitor='val_accuracy', verbose=1, patience=5)

# 모델 체크 포인트

check_point = ModelCheckpoint('best_model.keras', verbose=1, monitor='val_loss', save_best_only=True)

# 모델 학습

history = model.fit(X_train_over, y_train_over, epochs=50 , batch_size=32, validation_data=(X_test, y_test), callbacks=[early_stop, check_point])

 

 

평가

1. 분류 평가

print(classification_report(y_test, lgbm_pred))

 

2. 정확도/재현율

pred = model.predict(X_test)

y_pred = np.argmax(pred, axis=1)

print( accuracy_score(y_test, y_pred) )

print( recall_score(y_test, y_pred) )