#1 교육정리
오늘은 머신러닝의 성능을 더욱 높이기 위한 방법의 2가지를 배웠습니다.
1) SelectFromModel
2) Optuna
#2 SelectFromModel
selectfrommodel은 scikit-learn의 0.17 버전의 새로운 기능입니다. scikit-learn API에서 제공하는 가중치의 중요도에 따라 주어진 데이터셋의 최상의 특징을 추출하기 위한 클래스입니다. 주어진 임계값과 비교하여 가중치를 결정하는 메타 추정기입니다.
scikit-learn에서 제공하는 wine _data를 가져와서 xgb boost로 selectfrommodel을 적용해 분류 모델의 정확도를 확인해보겠습니다.
해당 wine dataset에서는 선택된 특성을 이용해 정확도를 예측했을 때보다 기존의 예측 정확도가 더욱 높은 것을 확인 할 수 있습니다.
import numpy as np
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split, StratifiedKFold, cross_val_score, cross_val_predict
from sklearn.utils import all_estimators
from sklearn.preprocessing import MinMaxScaler, StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
import tensorflow as tf
tf.random.set_seed(77) # weight 난수값
import warnings
warnings.filterwarnings('ignore')
#1. 데이터
datasets = load_wine()
x = datasets.data
y = datasets.target
feature_name = datasets.feature_names
print(feature_name)
x_train, x_test, y_train, y_test = train_test_split(
x, y, train_size=0.8, shuffle=True, random_state=64
)
### kfold ###
n_splits = 5
random_state = 64
kfold = StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=random_state)
scaler = MinMaxScaler()
scaler.fit(x_train)
x_train = scaler.transform(x_train)
x_test = scaler.transform(x_test)
#2. 모델구성
from xgboost import XGBClassifier
model = XGBClassifier()
#3. 훈련
model.fit(x_train, y_train, early_stopping_rounds=100,
eval_set = [(x_train, y_train), (x_test, y_test)],
eval_metric='merror')
#4. 출력(평가, 예측)
result = model.score(x_test, y_test)
print('acc : ', result)
score = cross_val_score(model, x_train, y_train, cv=kfold) # cv='cross validation'
print('cv acc : ', score)
y_predict = cross_val_predict(model, x_test, y_test, cv=kfold)
print('cv pred : ', y_predict)
acc = accuracy_score(y_test, y_predict)
print('cv pred acc : ', acc)
# acc : 0.9722222222222222
# cv acc : [0.93103448 0.86206897 1. 1. 0.89285714]
# cv pred : [2 1 0 2 0 1 2 2 2 2 1 1 2 0 2 1 0 1 2 0 1 2 1 2 1 0 2 1 1 0 1 0 2 2 2 1]
# cv pred acc : 0.9166666666666666
from sklearn.feature_selection import SelectFromModel
thresholds = model.feature_importances_
print("=========== SelectFromModel ===============")
for thresh in thresholds: # thresholds 라는 변수에 저장된 임계값들을 순회하고 반복
selection = SelectFromModel(model, threshold=thresh, prefit=True) #prefit=True는 이미 학습된 모델을 사용하여 특성 선택을 수행
select_x_train = selection.transform(x_train)
select_x_test = selection.transform(x_test)
print(select_x_train.shape, select_x_test.shape)
selection_model = XGBClassifier(n_jobs=-1,
random_state=123,
n_estimators=1000,
learning_rate = 0.1,
max_depth = 6,
gamma= 1,)
selection_model.fit(select_x_train, y_train)
y_predict = selection_model.predict(select_x_test)
score = accuracy_score(y_test, y_predict)
print("Thresh=%.3f, n=%d, Acc:%.2f%%"
%(thresh, select_x_train.shape[1], score*100)) # 현재 임계값(thresh)에 대한 특성 선택된 개수와 정확도를 출력
# 컬럼명 출력
selected_feature_indices = selection.get_support(indices=True) #선택된 측성의 인덱스를 가져옴
selected_feature_names = [feature_name[i] for i in selected_feature_indices]
print(selected_feature_names) # 선택된 특성으 인덱스를 기반으로 이름을 가져오며,
# feature_name 리스트에서 해당 인텍스의 요소를 가져옴
# =========== SelectFromModel ===============
# (142, 7) (36, 7) => 임계값 0.187에 대한 특성 선택을 수행한 결과, (142, 7)은 훈련데이터 / (36, 7))은 테스트데이터
# (142, 8) (36, 8)
# (142, 10) (36, 10)
# (142, 12) (36, 12)
# (142, 5) (36, 5)
# (142, 9) (36, 9)
# (142, 1) (36, 1)
# (142, 13) (36, 13)
# (142, 6) (36, 6)
# (142, 2) (36, 2)
# (142, 11) (36, 11)
# (142, 4) (36, 4)
# (142, 3) (36, 3)
# Thresh=0.187, n=3, Acc:94.44% => 임계값이 0.187일 때, 선택된 특성의 개수는 3개이며, 예측 정확도는 94.44%
# ['flavanoids', 'color_intensity', 'proline'] => 선택된 특성의 이름
#3 Optuna
이번에는 성능 향상을 위한 또 다른 방법을 소개해드리겠습니다.
optuna를 통해 최적의 하이퍼파라미터를 평가하고 추출하여 각 boost 모델에 적용해 결과를 도출해보겠습니다.
optuna는 하이퍼파라미터튜닝에 쓰고 있는 최신 Automl 기법입니다. 빠르게 튜닝이 가능하다는 장점이 있습니다.
또한 다른 라이브러리들에 비해 직관적인 장점이 있어 코딩을 하기에 용이 합니다.
brazilian_medical_noshow data로 optuna를 학습 해보겠습니다.
Optuna_XGBoost)
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import time
import optuna
import warnings
from sklearn.svm import SVC, LinearSVC
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split, StratifiedKFold, cross_val_score, cross_val_predict
from sklearn.preprocessing import MinMaxScaler, StandardScaler, LabelEncoder
from sklearn.covariance import EllipticEnvelope
from sklearn.metrics import mean_absolute_error
from optuna import Trial, visualization
from optuna.samplers import TPESampler
from xgboost import XGBClassifier
warnings.filterwarnings('ignore')
# Data preprocessing #
path = '../AI_study/'
df = pd.read_csv(path + 'medical_noshow.csv')
# CSV 파일을 읽어와서 DataFrame으로 저장
# print(medical_noshow.columns)
# print(medical_noshow.head(10))
print('Count of rows', str(df.shape[0]))
print('Count of Columns', str(df.shape[1]))
# 데이터프레임의 크기와 칼럼의 수를 출력
df = df.fillna(np.nan) # 결측값 nan으로 채우기
for column_name in df.columns:
print(column_name+":",len(df[column_name].unique()))
# 데이터프레임의 각 칼럼에 대해 유일한 값의 수를 출력
df['ScheduledDay'] = pd.to_datetime(df['ScheduledDay']).dt.date
df['AppointmentDay'] = pd.to_datetime(df['AppointmentDay']).dt.date
# 'ScheduledDay' 칼럼과 'AppointmentDay' 열을 날짜 형식으로 변환
df['Day_diff'] = (df['AppointmentDay'] - df['ScheduledDay']).dt.days
# 'Day_diff' 칼럼을 생성하여 약속 일자와 예약 일자의 차이를 계산
print("Day_diff값 목록 \n",df['Day_diff'].unique())
# Day_diff' 칼럼의 유일한 값을 출력
print(df[df['Day_diff']<0]['No-show'])
# Day_diff<0 인 데이터는 노쇼로 처리했음을 확인
df.info()
print(df['No-show'][0:10])
# 각 컬럼의 데이터 타입 확인
ob_col = list(df.dtypes[df.dtypes=='object'].index)
### data type이 object인 data들의 index를 ob_col 리스트에 저장
for col in ob_col:
df[col] = LabelEncoder().fit_transform(df[col].values)
# object인 데이터를 숫자형 데이터로 변환
df.info()
print(df['No-show'][0:10])
# [ no : 0, yes : 1 ]으로 정수화 되었음을 확인
# 각 컬럼의 데이터 타입 확인
df['PreviousApp'] = df.groupby(['PatientId']).cumcount()
# 'PatientId'가 같은 데이터끼리 그룹으로 묶어서 개수를 카운트 -> 각 환자별 이전 약속 수를 계산
# 이 값으로 'PreviousApp' 열을 생성
df['PreviousNoShow'] = (df[df['PreviousApp'] > 0].groupby(['PatientId'])['No-show'].cumsum() / df[df['PreviousApp'] > 0]['PreviousApp'])
# 이전에 예약한 기록이 있는 환자들만 선택,
# 'PatientId'가 같은 데이터끼리 그룹으로 묶어서 환자별로 고려,
# 이전에 noShow한 횟수의 합/이전에 예약한 횟수 = 해당 환자의 noShow 비율 계산
# 'PreviousNoShow' 칼럼을 생성하여 이전 약속에서의 No-show 비율 칼럼 생성
df['PreviousNoShow'] = df['PreviousNoShow'].fillna(0)
# 'PreviousNoShow' 칼럼의 NaN 값을 0으로 채운다.
# 즉, 첫 예약자는 이전에 noShow 안한것으로 간주
# Number of Appointments Missed by Patient
df['Num_App_Missed'] = df.groupby('PatientId')['No-show'].cumsum()
# 'PatientId'가 같은 데이터끼리 그룹으로 묶어서 환자별로 고려,
# 'Num_App_Missed' 각 환자별 누적 No-show 수를 계산한 칼럼을 생성
# print("handcap 종류 : ",df['Handcap'].unique())
df['Handcap'] = pd.Categorical(df['Handcap'])
# 핸드캡을 범주형 데이터로 변환
Handicap = pd.get_dummies(df['Handcap'], prefix = 'Handicap')
# 핸드캡 칼럼을 핸디캡 더미 변수로 변환
# prefix='Handicap'는 생성된 더미 변수의 이름에 'Handicap' 접두사를 붙이도록 지정
df = pd.concat([df, Handicap], axis=1)
# 데이터 프레임에 핸디캡 변수를 추가, 데이터 프레임을 열방향으로 병합
df.drop(['Handcap','ScheduledDay','AppointmentDay', 'AppointmentID','PatientId','Neighbourhood'], axis=1, inplace=True)
# 불필요한 칼럼 삭제, inplace=True 파라미터를 통해 원본 데이터프레임 수정
print(df.describe())
df = df[(df.Age >= 0) & (df.Age <= 100)]
df.info()
# 'Age' 열의 값이 0 이상 100 이하인 행만 선택 # 이외의 값은 이상치로 판정
x = df.drop(['No-show'], axis=1)
y = df['No-show']
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
x = scaler.fit_transform(x)
# Min-Max 스케일링을 사용하여 특성 값을 0과 1 사이로 조정
##### Complete Data Preprocessing #####
x_train, x_test, y_train, y_test = train_test_split(
x, y, test_size=0.2, random_state=77, shuffle=True
)
def objectiveXGB(trial: Trial, x_train, y_train, x_test):
param = {
'n_estimators' : trial.suggest_int('n_estimators', 500, 4000),
'max_depth' : trial.suggest_int('max_depth', 8, 16),
'random_state' : trial.suggest_int('random_state', 1, 2000)
}
# 학습 모델 생성
model = XGBClassifier(**param)
XGB_model = model.fit(x_train, y_train, verbose=True) # 학습 진행
# 모델 성능 확인
score = accuracy_score(XGB_model.predict(x_test), y_test)
return score
# MAE가 최소가 되는 방향으로 학습을 진행
# TPESampler : Sampler using TPE (Tree-structured Parzen Estimator) algorithm.
study = optuna.create_study(direction='maximize', sampler=TPESampler())
# n_trials 지정해주지 않으면, 무한 반복
study.optimize(lambda trial : objectiveXGB(trial, x, y, x_test), n_trials = 5)
print('Best trial : score {}, /nparams {}'.format(study.best_trial.value,
study.best_trial.params))
# 하이퍼파라미터별 중요도를 확인할 수 있는 그래프
print(optuna.visualization.plot_param_importances(study))
# 하이퍼파라미터 최적화 과정을 확인
optuna.visualization.plot_optimization_history(study)
plt.show()
## XGB 최적의 하이퍼파라미터 ##
#Best trial : score 0.9977379659790083, /nparams {'n_estimators': 3676, 'max_depth': 12, 'random_state': 1465}
Optuna_LGBM)
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import time
import optuna
import warnings
from sklearn.svm import SVC, LinearSVC
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split, StratifiedKFold, cross_val_score, cross_val_predict
from sklearn.preprocessing import MinMaxScaler, StandardScaler, LabelEncoder
from sklearn.covariance import EllipticEnvelope
from sklearn.metrics import mean_absolute_error
from optuna import Trial, visualization
from optuna.samplers import TPESampler
from lightgbm import LGBMClassifier
warnings.filterwarnings('ignore')
# Data preprocessing #
path = '../AI_study/'
df = pd.read_csv(path + 'medical_noshow.csv')
# CSV 파일을 읽어와서 DataFrame으로 저장
# print(medical_noshow.columns)
# print(medical_noshow.head(10))
print('Count of rows', str(df.shape[0]))
print('Count of Columns', str(df.shape[1]))
# 데이터프레임의 크기와 칼럼의 수를 출력
df = df.fillna(np.nan) # 결측값 nan으로 채우기
for column_name in df.columns:
print(column_name+":",len(df[column_name].unique()))
# 데이터프레임의 각 칼럼에 대해 유일한 값의 수를 출력
df['ScheduledDay'] = pd.to_datetime(df['ScheduledDay']).dt.date
df['AppointmentDay'] = pd.to_datetime(df['AppointmentDay']).dt.date
# 'ScheduledDay' 칼럼과 'AppointmentDay' 열을 날짜 형식으로 변환
df['Day_diff'] = (df['AppointmentDay'] - df['ScheduledDay']).dt.days
# 'Day_diff' 칼럼을 생성하여 약속 일자와 예약 일자의 차이를 계산
print("Day_diff값 목록 \n",df['Day_diff'].unique())
# Day_diff' 칼럼의 유일한 값을 출력
print(df[df['Day_diff']<0]['No-show'])
# Day_diff<0 인 데이터는 노쇼로 처리했음을 확인
df.info()
print(df['No-show'][0:10])
# 각 컬럼의 데이터 타입 확인
ob_col = list(df.dtypes[df.dtypes=='object'].index)
### data type이 object인 data들의 index를 ob_col 리스트에 저장
for col in ob_col:
df[col] = LabelEncoder().fit_transform(df[col].values)
# object인 데이터를 숫자형 데이터로 변환
df.info()
print(df['No-show'][0:10])
# [ no : 0, yes : 1 ]으로 정수화 되었음을 확인
# 각 컬럼의 데이터 타입 확인
df['PreviousApp'] = df.groupby(['PatientId']).cumcount()
# 'PatientId'가 같은 데이터끼리 그룹으로 묶어서 개수를 카운트 -> 각 환자별 이전 약속 수를 계산
# 이 값으로 'PreviousApp' 열을 생성
df['PreviousNoShow'] = (df[df['PreviousApp'] > 0].groupby(['PatientId'])['No-show'].cumsum() / df[df['PreviousApp'] > 0]['PreviousApp'])
# 이전에 예약한 기록이 있는 환자들만 선택,
# 'PatientId'가 같은 데이터끼리 그룹으로 묶어서 환자별로 고려,
# 이전에 noShow한 횟수의 합/이전에 예약한 횟수 = 해당 환자의 noShow 비율 계산
# 'PreviousNoShow' 칼럼을 생성하여 이전 약속에서의 No-show 비율 칼럼 생성
df['PreviousNoShow'] = df['PreviousNoShow'].fillna(0)
# 'PreviousNoShow' 칼럼의 NaN 값을 0으로 채운다.
# 즉, 첫 예약자는 이전에 noShow 안한것으로 간주
# Number of Appointments Missed by Patient
df['Num_App_Missed'] = df.groupby('PatientId')['No-show'].cumsum()
# 'PatientId'가 같은 데이터끼리 그룹으로 묶어서 환자별로 고려,
# 'Num_App_Missed' 각 환자별 누적 No-show 수를 계산한 칼럼을 생성
# print("handcap 종류 : ",df['Handcap'].unique())
df['Handcap'] = pd.Categorical(df['Handcap'])
# 핸드캡을 범주형 데이터로 변환
Handicap = pd.get_dummies(df['Handcap'], prefix = 'Handicap')
# 핸드캡 칼럼을 핸디캡 더미 변수로 변환
# prefix='Handicap'는 생성된 더미 변수의 이름에 'Handicap' 접두사를 붙이도록 지정
df = pd.concat([df, Handicap], axis=1)
# 데이터 프레임에 핸디캡 변수를 추가, 데이터 프레임을 열방향으로 병합
df.drop(['Handcap','ScheduledDay','AppointmentDay', 'AppointmentID','PatientId','Neighbourhood'], axis=1, inplace=True)
# 불필요한 칼럼 삭제, inplace=True 파라미터를 통해 원본 데이터프레임 수정
print(df.describe())
df = df[(df.Age >= 0) & (df.Age <= 100)]
df.info()
# 'Age' 열의 값이 0 이상 100 이하인 행만 선택 # 이외의 값은 이상치로 판정
x = df.drop(['No-show'], axis=1)
y = df['No-show']
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
x = scaler.fit_transform(x)
# Min-Max 스케일링을 사용하여 특성 값을 0과 1 사이로 조정
##### Complete Data Preprocessing #####
x_train, x_test, y_train, y_test = train_test_split(
x, y, test_size=0.2, random_state=77, shuffle=True
)
def objectiveLGBM(trial: Trial, x_train, y_train, x_test):
param = {
'n_estimators' : trial.suggest_int('n_estimators', 500, 4000),
'learning_rate' : trial.suggest_float('learning_rate', 0, 1),
'random_state' :trial.suggest_int('random_state', 1, 2000)
}
# 학습 모델 생성
model = LGBMClassifier(**param)
XGB_model = model.fit(x_train, y_train, verbose=True) # 학습 진행
# 모델 성능 확인
score = accuracy_score(XGB_model.predict(x_test), y_test)
return score
# MAE가 최소가 되는 방향으로 학습을 진행
# TPESampler : Sampler using TPE (Tree-structured Parzen Estimator) algorithm.
study = optuna.create_study(direction='maximize', sampler=TPESampler())
# n_trials 지정해주지 않으면, 무한 반복
study.optimize(lambda trial : objectiveLGBM(trial, x, y, x_test), n_trials = 5)
print('Best trial : score {}, /nparams {}'.format(study.best_trial.value,
study.best_trial.params))
# 하이퍼파라미터별 중요도를 확인할 수 있는 그래프
print(optuna.visualization.plot_param_importances(study))
# 하이퍼파라미터 최적화 과정을 확인
optuna.visualization.plot_optimization_history(study)
plt.show()
## LGBM 최적의 하이퍼파라미터 ##
#Best trial : score 0.997828447339848, /nparams {'n_estimators': 3855, 'learning_rate': 0.44236276056374924, 'random_state': 1069}
Optuna_CatBoost)
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import time
import optuna
import warnings
from sklearn.svm import SVC, LinearSVC
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split, StratifiedKFold, cross_val_score, cross_val_predict
from sklearn.preprocessing import MinMaxScaler, StandardScaler, LabelEncoder
from sklearn.covariance import EllipticEnvelope
from sklearn.metrics import mean_absolute_error
from optuna import Trial, visualization
from optuna.samplers import TPESampler
from catboost import CatBoostClassifier
warnings.filterwarnings('ignore')
# Data preprocessing #
path = '../AI_study/'
df = pd.read_csv(path + 'medical_noshow.csv')
# CSV 파일을 읽어와서 DataFrame으로 저장
# print(medical_noshow.columns)
# print(medical_noshow.head(10))
print('Count of rows', str(df.shape[0]))
print('Count of Columns', str(df.shape[1]))
# 데이터프레임의 크기와 칼럼의 수를 출력
df = df.fillna(np.nan) # 결측값 nan으로 채우기
for column_name in df.columns:
print(column_name+":",len(df[column_name].unique()))
# 데이터프레임의 각 칼럼에 대해 유일한 값의 수를 출력
df['ScheduledDay'] = pd.to_datetime(df['ScheduledDay']).dt.date
df['AppointmentDay'] = pd.to_datetime(df['AppointmentDay']).dt.date
# 'ScheduledDay' 칼럼과 'AppointmentDay' 열을 날짜 형식으로 변환
df['Day_diff'] = (df['AppointmentDay'] - df['ScheduledDay']).dt.days
# 'Day_diff' 칼럼을 생성하여 약속 일자와 예약 일자의 차이를 계산
print("Day_diff값 목록 \n",df['Day_diff'].unique())
# Day_diff' 칼럼의 유일한 값을 출력
print(df[df['Day_diff']<0]['No-show'])
# Day_diff<0 인 데이터는 노쇼로 처리했음을 확인
df.info()
print(df['No-show'][0:10])
# 각 컬럼의 데이터 타입 확인
ob_col = list(df.dtypes[df.dtypes=='object'].index)
### data type이 object인 data들의 index를 ob_col 리스트에 저장
for col in ob_col:
df[col] = LabelEncoder().fit_transform(df[col].values)
# object인 데이터를 숫자형 데이터로 변환
df.info()
print(df['No-show'][0:10])
# [ no : 0, yes : 1 ]으로 정수화 되었음을 확인
# 각 컬럼의 데이터 타입 확인
df['PreviousApp'] = df.groupby(['PatientId']).cumcount()
# 'PatientId'가 같은 데이터끼리 그룹으로 묶어서 개수를 카운트 -> 각 환자별 이전 약속 수를 계산
# 이 값으로 'PreviousApp' 열을 생성
df['PreviousNoShow'] = (df[df['PreviousApp'] > 0].groupby(['PatientId'])['No-show'].cumsum() / df[df['PreviousApp'] > 0]['PreviousApp'])
# 이전에 예약한 기록이 있는 환자들만 선택,
# 'PatientId'가 같은 데이터끼리 그룹으로 묶어서 환자별로 고려,
# 이전에 noShow한 횟수의 합/이전에 예약한 횟수 = 해당 환자의 noShow 비율 계산
# 'PreviousNoShow' 칼럼을 생성하여 이전 약속에서의 No-show 비율 칼럼 생성
df['PreviousNoShow'] = df['PreviousNoShow'].fillna(0)
# 'PreviousNoShow' 칼럼의 NaN 값을 0으로 채운다.
# 즉, 첫 예약자는 이전에 noShow 안한것으로 간주
# Number of Appointments Missed by Patient
df['Num_App_Missed'] = df.groupby('PatientId')['No-show'].cumsum()
# 'PatientId'가 같은 데이터끼리 그룹으로 묶어서 환자별로 고려,
# 'Num_App_Missed' 각 환자별 누적 No-show 수를 계산한 칼럼을 생성
# print("handcap 종류 : ",df['Handcap'].unique())
df['Handcap'] = pd.Categorical(df['Handcap'])
# 핸드캡을 범주형 데이터로 변환
Handicap = pd.get_dummies(df['Handcap'], prefix = 'Handicap')
# 핸드캡 칼럼을 핸디캡 더미 변수로 변환
# prefix='Handicap'는 생성된 더미 변수의 이름에 'Handicap' 접두사를 붙이도록 지정
df = pd.concat([df, Handicap], axis=1)
# 데이터 프레임에 핸디캡 변수를 추가, 데이터 프레임을 열방향으로 병합
df.drop(['Handcap','ScheduledDay','AppointmentDay', 'AppointmentID','PatientId','Neighbourhood'], axis=1, inplace=True)
# 불필요한 칼럼 삭제, inplace=True 파라미터를 통해 원본 데이터프레임 수정
print(df.describe())
df = df[(df.Age >= 0) & (df.Age <= 100)]
df.info()
# 'Age' 열의 값이 0 이상 100 이하인 행만 선택 # 이외의 값은 이상치로 판정
x = df.drop(['No-show'], axis=1)
y = df['No-show']
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
x = scaler.fit_transform(x)
# Min-Max 스케일링을 사용하여 특성 값을 0과 1 사이로 조정
##### Complete Data Preprocessing #####
x_train, x_test, y_train, y_test = train_test_split(
x, y, test_size=0.2, random_state=77, shuffle=True
)
def objectiveCat(trial: Trial, x_train, y_train, x_test):
param = {
'n_estimators' : trial.suggest_int('n_estimators', 500, 4000),
'depth' : trial.suggest_int('depth', 8, 16),
'fold_permutation_block' : trial.suggest_int('fold_permutation_block', 1, 256),
'learning_rate' : trial.suggest_float('learning_rate', 0, 1),
'od_pval' : trial.suggest_float('od_pval', 0, 1),
'l2_leaf_reg' : trial.suggest_float('l2_leaf_reg', 0, 4),
'random_state' :trial.suggest_int('random_state', 1, 2000)
}
# 학습 모델 생성
model = CatBoostClassifier(**param)
XGB_model = model.fit(x_train, y_train, verbose=True) # 학습 진행
# 모델 성능 확인
score = accuracy_score(XGB_model.predict(x_test), y_test)
return score
# MAE가 최소가 되는 방향으로 학습을 진행
# TPESampler : Sampler using TPE (Tree-structured Parzen Estimator) algorithm.
study = optuna.create_study(direction='maximize', sampler=TPESampler())
# n_trials 지정해주지 않으면, 무한 반복
study.optimize(lambda trial : objectiveCat(trial, x, y, x_test), n_trials = 5)
print('Best trial : score {}, /nparams {}'.format(study.best_trial.value,
study.best_trial.params))
# 하이퍼파라미터별 중요도를 확인할 수 있는 그래프
print(optuna.visualization.plot_param_importances(study))
# 하이퍼파라미터 최적화 과정을 확인
optuna.visualization.plot_optimization_history(study)
plt.show()
## Cat 최적의 하이퍼파라미터 ##
#Best trial : score 0.9980094100615273, /nparams {'n_estimators': 939, 'depth': 14, 'fold_permutation_block': 70, 'learning_rate': 0.5787982175373018, 'od_pval': 0.671062923929216, 'l2_leaf_reg': 1.8747109317317627, 'random_state': 618}
Optuna Voting)
각 부스트에서 최적의 하이퍼파라미터들을 voting 모델로 한번에 성능 평가 해보겠습니다.
정확도를 보시면 하이퍼파라미터를 추출하는 과정의 catboost의 정확도가 가장 높은것을 확인 할 수 있습니다.
#!/usr/bin/env python
# coding: utf-8
import numpy as np
import pandas as pd
import time
import warnings
from keras.models import Sequential
from keras.layers import Dense
from sklearn.model_selection import train_test_split, StratifiedKFold
from sklearn.metrics import accuracy_score
from sklearn.preprocessing import MinMaxScaler
from sklearn.covariance import EllipticEnvelope
from sklearn.preprocessing import LabelEncoder
from sklearn.ensemble import VotingClassifier
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier
from catboost import CatBoostClassifier
warnings.filterwarnings('ignore')
# Data preprocessing #
path = '../AI_study/'
df = pd.read_csv(path + 'medical_noshow.csv')
# CSV 파일을 읽어와서 DataFrame으로 저장
# print(medical_noshow.columns)
# print(medical_noshow.head(10))
print('Count of rows', str(df.shape[0]))
print('Count of Columns', str(df.shape[1]))
# 데이터프레임의 크기와 열의 수를 출력
df.isnull().any().any()
for i in df.columns:
print(i+":",len(df[i].unique()))
# 데이터프레임의 각 열에 대해 유일한 값의 수를 출력
df['PatientId'].astype('int64')
df.set_index('AppointmentID', inplace = True)
# 'PatientId' 열을 정수형으로 변환하고, 'AppointmentID'를 인덱스로 설정
df['No-show'] = df['No-show'].map({'No':0, 'Yes':1})
# 'No-show' 열의 값('No', 'Yes')을 0과 1로 매핑
df['Gender'] = df['Gender'].map({'F':0, 'M':1})
# 'Gender' 열의 값('F', 'M')을 0과 1로 매핑
df['PreviousApp'] = df.sort_values(by = ['PatientId','ScheduledDay']).groupby(['PatientId']).cumcount()
# 'PreviousApp' 열을 생성하여 각 환자별 이전 약속 수를 계산
df['PreviousNoShow'] = (df[df['PreviousApp'] > 0].sort_values(['PatientId', 'ScheduledDay']).groupby(['PatientId'])['No-show'].cumsum() / df[df['PreviousApp'] > 0]['PreviousApp'])
# 'PreviousNoShow' 열을 생성하여 이전 약속에서의 No-show 비율을 계산
df['PreviousNoShow'] = df['PreviousNoShow'].fillna(0)
df['PreviousNoShow']
# 'PreviousNoShow' 열의 NaN 값을 0으로 채운다
# Number of Appointments Missed by Patient
df['Num_App_Missed'] = df.groupby('PatientId')['No-show'].apply(lambda x: x.cumsum())
df['Num_App_Missed']
# 'Num_App_Missed' 열을 생성하여 각 환자별 누적 No-show 수를 계산
df['ScheduledDay'] = pd.to_datetime(df['ScheduledDay']).dt.strftime('%Y-%m-%d')
df['ScheduledDay'] = pd.to_datetime(df['ScheduledDay'])
df['ScheduledDay']
df['AppointmentDay'] = pd.to_datetime(df['AppointmentDay']).dt.strftime('%Y-%m-%d')
df['AppointmentDay'] = pd.to_datetime(df['AppointmentDay'])
df['AppointmentDay']
# 'ScheduledDay' 열과 'AppointmentDay' 열을 날짜 형식으로 변환
df['Day_diff'] = (df['AppointmentDay'] - df['ScheduledDay']).dt.days
# 'Day_diff' 열을 생성하여 약속 일자와 예약 일자의 차이를 계산
df['Day_diff'].unique()
# Day_diff' 열의 유일한 값을 출력
df = df[(df.Age >= 0)]
# 'Age' 열의 값이 0 이상 행만 선택
df.drop(['ScheduledDay'], axis=1, inplace=True)
df.drop(['AppointmentDay'], axis=1, inplace=True)
df.drop('PatientId', axis=1,inplace = True)
df.drop('Neighbourhood', axis=1,inplace = True)
# 불필요한 열('ScheduledDay', 'AppointmentDay', 'PatientId', 'Neighbourhood')을 삭제
#Convert to Categorical
df['Handcap'] = pd.Categorical(df['Handcap'])
#Convert to Dummy Variables
Handicap = pd.get_dummies(df['Handcap'], prefix = 'Handicap')
df = pd.concat([df, Handicap], axis=1)
df.drop(['Handcap'], axis=1, inplace = True)
# 'Handcap' 열을 범주형으로 변환하고, 더미 변수로 변환
df = df[(df.Age >= 0) & (df.Age <= 100)]
df.info()
# 'Age' 열의 값이 0 이상 100 이하인 행만 선택
x = df.drop(['No-show'], axis=1)
y = df['No-show']
scaler = MinMaxScaler()
x = scaler.fit_transform(x)
# Min-Max 스케일링을 사용하여 특성 값을 0과 1 사이로 조정
##### Complete Data Preprocessing #####
######### voting ############
x_train, x_test, y_train, y_test = train_test_split(
x, y, train_size=0.6, test_size=0.2, random_state=100, shuffle=True
)
x_train = scaler.fit_transform(x_train)
x_test = scaler.transform(x_test)
n_splits = 5
random_state = 42
kfold = StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=random_state)
xgb = XGBClassifier(
n_estimators=3676,
max_depth=12,
random_state=1465
) # optuna로 산출한 best_parameter 적용
lgbm = LGBMClassifier(
n_estimators=3855,
learning_rate=0.44236276056374924,
random_state=1069
) # optuna로 산출한 best_parameter 적용
cat = CatBoostClassifier(
n_estimators=939,
depth=14,
fold_permutation_block=70,
learning_rate=0.5787982175373018,
od_pval=0.671062923929216,
l2_leaf_reg=1.8747109317317627,
random_state=618
)# optuna로 산출한 best_parameter 적용
model = VotingClassifier(
estimators=[('xgb', xgb), ('lgbm', lgbm), ('cat', cat)],
voting='hard',
n_jobs=-1,
verbose=0
)
model.fit(x_train, y_train)
y_voting_predict = model.predict(x_test)
voting_score = accuracy_score(y_test, y_voting_predict)
print('voting result : ', voting_score)
classifiers = [cat, xgb, lgbm]
for model in classifiers:
model.fit(x_train, y_train)
y_predict = model.predict(x_test)
score = accuracy_score(y_test, y_predict)
class_name = model.__class__.__name__
print(class_name, "'s score : ", score)
print('Optuna -> voting')
### result ###
# voting result : 0.956795150199059
# CatBoostClassifier 's score : 0.9577904451682954
# XGBClassifier 's score : 0.9560260586319218
# LGBMClassifier 's score : 0.9551212450235251
#Optuna -> voting'[Naver Cloud Camp 7] 교육 정리' 카테고리의 다른 글
| 네이버 클라우드 캠프 20일차 230522 (2) | 2023.05.22 |
|---|---|
| 네이버 클라우드 캠프 18일차 230518 (0) | 2023.05.20 |
| 네이버 클라우드 캠프 16일차 230516 (0) | 2023.05.16 |
| 네이버 클라우드 캠프 15일차 230515 (0) | 2023.05.15 |
| 네이버 클라우드 캠프 14일차 230512 (1) | 2023.05.12 |
