티스토리 뷰
1. 항공권 가격 예측 모델링 [회귀]
1. 데이터 파악 및 전처리(결측치 처리, 중복 data point 처리, feature selection 등)
# 데이터 불러오기
# 판다스 라이브러리 불러오기
import pandas as pd
cdf = pd.read_csv("../data/Clean_Dataset.csv")
# 학습시간 단축을 위해 5000건만 추출하기
cdf = cdf[:5000]
# 데이터 확인하기
cdf.head(1)
-----------------------------------------------------------------------------------------------
# 데이터 전처리하기
# Unnamed: 0 데이터 분포 확인하기
cdf["Unnamed: 0"].value_counts()
# Unnamed 컬럼 삭제하기
cdf.drop("Unnamed: 0", axis = 1, inplace =True)
# 기초 통계정보 확인하기
cdf.describe(include='all')
# info를 통해 Null 데이터 및 type 확인 있는지 1차 확인하기(isna를 사용해도 됨)
print("Null 데이터 확인")
cdf.info()
# 첫 번째 컬럼이 의미있는 컬럼인지 확인하기 위해 value_count로 분포 확인하기
cdf.airline.value_counts()
# 그래프 라이브러리 불러오기(matplotlib, seaborn)
import matplotlib.pyplot as plt
import seaborn as sns
# Seaborn 으로 막대그래프 그리기
# 배경 사이즈 설정하기
plt.figure(figsize=(5,5))
# 막대그래프 차트 그리기
ax = sns.barplot(x='airline', y='price', data=cdf, hue='airline')
# 상단 타이틀 지정하기
ax.set(title='airline & price')
# 그래프 출력하기
plt.show()
# 2번째 flight 값 재확인하기
cdf.head(1)
# flight column 분포 확인하기
cdf.flight.value_counts()
# flight 칼럼은 다른 칼럼과 의미가 중복되는 것으로 보이므로 삭제하기
cdf.drop('flight', axis=1, inplace=True)
# 잘 삭제되었는지 shape 확인하기
cdf.shape
2. 원핫 인코딩
# one_hot 인코딩을 위해 get_dummies 처리하기
dummies_cdf = pd.get_dummies(cdf,
columns=["airline", 'source_city','departure_time', 'stops','arrival_time', 'destination_city', 'class'],
drop_first=True
)
# 인코딩 확인하기
print(f'''원핫인코딩 전 {cdf.shape}
원핫인코딩 후 {dummies_cdf.shape}''')
2. 학습 데이터 만들기
# 데이터프레임에서 타깃 변수만 y로 추출하기
y = dummies_cdf.price
# 데이터프레임에서 타깃 변수를 제외한 입력 데이터세트를 생성하기
x = dummies_cdf.drop('price', axis=1)
x.head(5)
# shape 확인하기
x.shape, y.shape
3. 모델 학습하기
# xgboost, lightgbm모델 설치하기
!pip install xgboost
!pip install lightgbm
# scikit learn 기반 라이브러리 불러오기
from sklearn.linear_model import LinearRegression
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.ensemble import ExtraTreesRegressor
# scikit learn 외 라이브러리 불러오기
from xgboost import XGBRFRegressor
from lightgbm import LGBMRegressor
# 학습_검증 데이터 분리 라이브러리 불러오기
from sklearn.model_selection import train_test_split
---------------------------------------------------------------------------------------------
# 머신러닝 모델 생성하기
# 모델 생성 시 n_jobs 옵션이 있는 모델은 -1을 적용하여 동작 시키는 것을 권유함
lr = LinearRegression( n_jobs=-1)
dtr = DecisionTreeRegressor( random_state=1)
rfr = RandomForestRegressor( random_state=1)
gbr = GradientBoostingRegressor( random_state=1)
xgbr = XGBRFRegressor(n_jobs=-1, random_state=1)
etr = ExtraTreesRegressor(n_jobs=-1, random_state=1)
lgbmr = LGBMRegressor(n_jobs=-1, random_state=1)
---------------------------------------------------------------------------------------------
# 훈련 데이터 분할하기
x_train, x_test, y_train ,y_test = train_test_split(x, y ,
test_size=0.3,
random_state=2023, # 서로 다른 결과를 나타내지 않기
)
# shape 확인하기
x_test.shape, y_test.shape
# shape 확인하기
x_train.shape, y_train.shape
---------------------------------------------------------------------------------------------
%%time
# 머신러닝 모델(base 모델) 학습하기
lr.fit(x_train, y_train)
dtr.fit(x_train, y_train)
rfr.fit(x_train, y_train)
gbr.fit(x_train, y_train)
xgbr.fit(x_train, y_train)
etr.fit(x_train, y_train)
lgbmr.fit(x_train, y_train)
---------------------------------------------------------------------------------------------
# 결과 검증용 라이브러리 불러오기
from sklearn.metrics import r2_score
from sklearn.metrics import mean_squared_error
# 리스트에 모델 입력하기
models = [lr, dtr, rfr, gbr, xgbr, etr, lgbmr]
r2_score_list = []
rmse_score_list = []
# 모델 결과 확인하기
for model in models:
pred = model.predict(x_test)
r2_score_list.append(
round(r2_score(y_test, pred),5)
)
# squared를 False로 하면 RMSE가 됨
rmse_score_list.append(
round(mean_squared_error(
y_test, pred, squared=False),5)
)
r2_score_df = pd.DataFrame([r2_score_list, rmse_score_list],
columns=["lr", "dtr", "rfr", "gbr", "xgbr", "etr","lgbmr"],
index=["r2", "rmse"]
)
r2_score_df
4. 최적의 파라미터 찾기(GridSearchCV)
# GridSearchCV 라이브러리 불러오기
from sklearn.model_selection import GridSearchCV
# 비교 하이퍼파라미터 선정하기
param_grid = {
'learning_rate': [0.1 ,0.01, 0.003],
'colsample_bytree': [0.5, 0.7],
'max_depth' : [ 20,30,40],
}
# 최적 하이퍼파라미터 검색하기
cv_lgbmr = GridSearchCV(estimator=lgbmr,
param_grid=param_grid,
cv= 5,
verbose=1
)
cv_lgbmr.fit(x_train, y_train)
# 최적 하이퍼파라미터 조합 확인하기
cv_lgbmr.best_params_
# 최적 하이퍼파라미터 결과 확인하기
cv_lgbmr.best_score_ # 예측 정확도 확인하기
-----------------------------------------------------------------------------------------------
# 머신러닝 모델 검증하기
# 최적의 하이퍼파라미터로 재학습하기
best_lgbmr = LGBMRegressor(max_depth= 30,
colsample_bytree= 0.7,
learning_rate= 0.1,
n_jobs=-1,
random_state= 1
)
best_lgbmr.fit(x_train,y_train)
# 모델 성능 검증하기
b_pred=best_lgbmr.predict(x_test)
print('r2 : ', round(r2_score(y_test, b_pred),5))
print('rmse : ', round(mean_squared_error(y_test, b_pred, squared=False),5))
Randomized Search CV로도 최적 파라미터 찾기 가능
# RandomizedSearchCV 라이브러리 호출하기
from sklearn.model_selection import RandomizedSearchCV
# 비교 파라미터 선정하기
param_dists = {
'learning_rate': [0.1 ,0.01, 0.003],
'colsample_bytree': [0.5, 0.7],
'max_depth' : [ 20,30,40],
}
%%time
# 최적 파라미터 검색하기
cv_lgbmr = RandomizedSearchCV(estimator=lgbmr,
param_distributions=param_dists,
n_iter = 500,
cv= 5,
verbose=1
)
cv_lgbmr.fit(x_train, y_train)
# 최적의 파라미터 조합 확인하기
cv_lgbmr.best_params_
2. 고객 만족여부 예측 모델링 [분류]
1. 데이터 전처리
# 데이터 불러오기
# 판다스 라이브러리 불러오기
import pandas as pd
# 파일이 저장된 경로에서 데이터 로딩하기
cdf = pd.read_csv("../data/Invistico_Airline.csv")
# 학습시간 단축을 위해 5,000건만 추출하기
cdf = cdf[:5000]
# 중간에 Column 이 '...'으로 표시되는 것 확인하기
cdf.head(1)
# 모든 칼럼을 표시하기
pd.set_option('display.max_columns', None)
cdf.head(1)
---------------------------------------------------------------------------------------------
# 데이터 전처리하기
# 레이블 불균형 확인
cdf.satisfaction.value_counts()
# null 데이터 확인하기
cdf.info()
# 결측치 행 삭제하기
cdf.dropna(axis=0, inplace=True)
# 삭제 여부 확인하기
cdf.info()
# 라벨 데이터 y를 나누기
# cdf 데이터프레임에서 label만 y로 추출하기
y = cdf.satisfaction
# price 칼럼 삭제하고 입력 데이터 만들기
x = cdf.drop("satisfaction", axis=1 )
# 데이터 크기 확인하기
x.shape, y.shape
2. 인코딩
# 원핫 인코딩하기 (인풋)
# info 메소드로 데이터 유형 확인하기
x.info()
# get_dummies 함수를 활용해 object 유형의 칼럼을 원핫 인코딩하기
x_gd = pd.get_dummies(x,
columns=['Gender', 'Customer Type',
'Type of Travel', 'Class'],
drop_first=False)
x_gd.info()
x_gd.head(5)
---------------------------------------------------------------------------------------------
# 레이블 인코딩하기 (아웃풋)
# 라이브러리 불러오기
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
# train_test_split 수행하기
x_train, x_test, y_train ,y_test = train_test_split( x_gd, y, stratify=y, test_size=0.2, random_state=2023)
# 레이블 인코더 생성하기
le = LabelEncoder()
# fit을 통해 y_train의 값마다 0과 1을 부여하는 규칙 생성하기
le.fit(y_train)
#y_train을 레이블 인코딩하기
le_y_train = le.transform(y_train)
#y_test를 레이블 인코딩하기
le_y_test = le.transform(y_test)
# 인코딩이 수행된 데이터 확인하기
print('레이블 인코딩 후 데이터 :',le_y_train)
# 라벨 별로 어떤 값이 부여되어 있는지 규칙 확인하기
print('레이블 인코딩 클래스 확인 :',le.classes_)
# 레이블 인코딩된 데이터를 디코딩했을 때 데이터 확인하기
print('레이블 인코딩을 디코딩 했을 때 :',le.inverse_transform(le_y_train))
3. 모델 학습하기
%%time
# 다양한 학습 모델 불러오기
# scikit-learn 기반 모델 불러오기
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.ensemble import ExtraTreesClassifier
# scikit-learn 이외의 모델 불러오기
from xgboost import XGBRFClassifier
from lightgbm import LGBMClassifier
# 모델 생성하기
lr = LogisticRegression()
dtc = DecisionTreeClassifier(random_state=1)
rfc = RandomForestClassifier(random_state=1)
gbc = GradientBoostingClassifier(random_state=1)
xgbc = XGBRFClassifier(random_state=1)
etc = ExtraTreesClassifier(random_state=1)
lgbmc = LGBMClassifier(random_state=1)
# 모델 학습 수행하기
lr.fit(x_train, le_y_train)
dtc.fit(x_train, le_y_train)
rfc.fit(x_train, le_y_train)
gbc.fit(x_train, le_y_train)
xgbc.fit(x_train, le_y_train)
etc.fit(x_train, le_y_train)
lgbmc.fit(x_train, le_y_train)
# 순서대로 적용할 모델을 리스트에 저장하기
models = [lr, dtc, rfc, gbc, xgbc, etc, lgbmc]
# for문을 활용해 학습 모델 별 Score를 리스트에 저장하기
acc_train_list = []
acc_test_list = []
for model in models:
acc_train_list.append(round(model.score(x_train, le_y_train),5))
acc_test_list.append(round(model.score(x_test, le_y_test),5))
# 모델 별 정확도를 출력하기
for i in range(len(models)):
print('학습모델 : ',models[i])
print('train 정확도: ',acc_train_list[i])
print('test 정확도: ',acc_test_list[i])
print('----------------------------------')- 모델 선택
4. 최적의 하이퍼파라미터 및 모델 재학습
%%time
#GridSearchCV를 불러오기
from sklearn.model_selection import GridSearchCV
# param_grid를 정의하여 각 파라미터 별로 교차해서 모든 학습을 수행하기
param_grid = {
'n_estimators': [50 ,100, 200, 500],
'max_features': ['sqrt', 'log2', None],
'max_depth' : [10,20,30,40,50,None],
}
# estimator=rfc :가장 우수한 모델이었던 rfc 활용하기
# param_grid=param_grid : 미리 정의한 파라미터들을 교차 적용하기
# n_jobs=-1 : -1로 지정하면 모든 CPU 활용하기
cv_rfc = GridSearchCV(
estimator=rfc,
param_grid=param_grid,
n_jobs=-1,
cv=5)
# 학습 수행하기
cv_rfc.fit(x_train, le_y_train)
# best_score를 출력하기
print('최적의 파라미터 학습시 Score :',round(cv_rfc.best_score_ , 5))
# best params을 출력하기
print('최적의 파라미터 :',cv_rfc.best_params_)
---------------------------------------------------------------------------------------------
# 최적의 하이퍼파라미터로 도출된 값을 모델에 입력하기
rfc = RandomForestClassifier(
n_estimators = 50,
max_features = None,
n_jobs=-1,
max_depth = 10)
# rfc 학습 수행하기
rfc.fit(x_train, le_y_train)
# 이전에 하이퍼파라미터 설정 없이 수행했을 때의 정확도 확인하기
print('기존 모델의 Test 정확도: 1.0')
# 최적의 하이퍼파라미터 입력 후 학습시킨 모델의 정확도 확인하기
print('최적의 하이퍼 파라미터 반영한 모델의 Test 정확도: ',round(rfc.score(x_test, le_y_test),5))
# 향상된 정확도 gap 계산하기
print('정확도 향상: ',round(rfc.score(x_test, le_y_test)-1.0 , 5))
5. 오차행렬으로 모델 평가하기
# 라이브러리 불러오기
from sklearn.metrics import confusion_matrix
from sklearn.metrics import ConfusionMatrixDisplay
from sklearn.metrics import classification_report
# rfc 모델로 x_test를 예측한 값을 y_pred로 저장하기
y_pred = rfc.predict(x_test)
# 실제값 le_y_test(레이블 인코딩을 해야 0,1로 표현됨)와 예측값 y_pred 비교하기
cm = confusion_matrix(le_y_test, y_pred, labels=[0,1])
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=[0,1])
disp.plot()
# 오차행렬(Confusion Matrix) 출력하기
plt.show()
# 오차행렬(Confusion Matrix)를 통한 각종 지표들을 리포트로 출력하기
print(classification_report(le_y_test, y_pred))