머신러닝(5)

함수 불러오기

# 라이브러리 불러오기
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier

from sklearn.metrics import *

 

 

LGBM

verbose=-1 : 출력 메세지 삭제

# 선언하기
#importance_type='gain'or 'split'
model = LGBMClassifier(max_depth=5, importance_type='gain', verbose=-1)

 

 

그리드 서치

# 선언하기
from sklearn.model_selection import GridSearchCV

# Grid Search 선언
model = GridSearchCV(DecisionTreeRegressor(random_state=1),     # 기본 모델
                     param,                       # 파라미터 범위
                     cv=5,                        # K폴드 개수
                     scoring='r2')                # 평가지표 (기본값 r2) / neg_mean
                     
                     
               
               
print('최적파라미터:', model.best_params_)
print('최고성능:', model.best_score_)

 

 

클래스 불균형 해결

언더 샘플링

# 불러오기
from imblearn.under_sampling import RandomUnderSampler

# Under Sampling
under_sample = RandomUnderSampler()
u_x_train, u_y_train = under_sample.fit_resample(x_train, y_train)

# 확인
print('전:', np.bincount(y_train))
print('후:', np.bincount(u_y_train))

# 출력
전: [735  70]
후: [70 70]

 

 

오버 샘플링

# 불러오기
from imblearn.over_sampling import RandomOverSampler

# Over Sampling
over_sample = RandomOverSampler()
o_x_train, o_y_train = over_sample.fit_resample(x_train, y_train)

# 확인
print('전:', np.bincount(y_train))
print('후:', np.bincount(o_y_train))

# 출력
전: [735  70]
후: [735 735]

 

 

오버 샘플링 - 스모트

# 불러오기
from imblearn.over_sampling import SMOTE

# Over Sampling
smote = SMOTE()
s_x_train, s_y_train = smote.fit_resample(x_train, y_train)

# 확인
print('전:', np.bincount(y_train))
print('후:', np.bincount(s_y_train))

# 출력
전: [735  70]
후: [735 735]

 

 

calss_weight 파라미터

# 선언하기
model = RandomForestClassifier(max_depth=5, random_state=1, class_weight='balanced')

# 학습하기
model.fit(x_train, y_train)

# 예측하기
y_pred = model.predict(x_test)

# 평가하기
print(confusion_matrix(y_test, y_pred))
print(classification_report(y_test, y_pred))

 

 

보팅: 개별 모델의 예측 결과를 집계하여 성능 예측

- 하드 보팅: 각 분류 모델의 예측 결과를 다수결로 최종 예측을 결정

- 소프트 보팅: 각 분류 모델의 예측 확률 값을 평균 내어 가장 높은 확률을 가진 클래스로 예측

# 보팅 모델 선언
estimators = [('lr', model_lr), 
              ('knn', model_knn), 
              ('dt', model_dt), 
              ('rdf', model_rdf), 
              ('lgb', model_lgb)]

model = VotingRegressor(estimators=estimators)

# 학습하기
model.fit(x_train, y_train)

# 예측하기
y_pred = model.predict(x_test)

# 평가하기
print('* MAE:', mean_absolute_error(y_test, y_pred))
print('* R2:', r2_score(y_test, y_pred))

 

 

스태킹: 모델 예측 값을 구한 후 이 예측 값을 최종 모델인 Randomforest로 학습하여 예측

# 스태킹 모델 선언
estimators = [('lr', model_lr), 
              ('dt', model_dt), 
              ('knn', model_knn), 
              ('lgb', model_lgb)]

model = StackingClassifier(estimators=estimators, final_estimator=RandomForestClassifier(random_state=1))

# 학습하기
model.fit(x_train, y_train)

# 예측하기
y_pred = model.predict(x_test)

# 평가하기
print(confusion_matrix(y_test, y_pred))
print(classification_report(y_test, y_pred))