사이킷런(Scikit-learn) 머신러닝 주요 모델 정리

0. (공통)환경 세팅 및 데이터 탐색

# 코드실행시 경고 메시지 무시
import warnings
warnings.filterwarnings(action='ignore')

0-1. 라이브러리 불러오기

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings

warnings.filterwarnings(action='ignore')
%config InlineBackend.figure_format = 'retina'

0-2. 데이터 읽어오기

# 회귀 모델용 예제 데이터 (보스턴의 집 값을 예측)
path_Regression = 'https://raw.githubusercontent.com/cocodolong/blog_database/main/Dataset/Dataset_Boston%20Housing%20Price.csv'
data_Regression = pd.read_csv(path_Regression)
data_Regression.to_csv("보스턴집값")

# 분류 모델용 예제 데이터 (타이타닉 승객의 생존여부 예측)
path_Classifier = 'https://raw.githubusercontent.com/cocodolong/blog_database/main/Dataset/Dataset_Titanic.csv'
data_Classifier = pd.read_csv(path_Classifier)
data_Classifier.to_csv("타이타닉승객", index=True, header=False)

0-3. 데이터 탐색

# 상위 3개 행 확인
display(data_Regression.head(3))
display(data_Classifier.head(3))

# 하위 3개 행 확인
display(data_Regression.tail(3))
display(data_Classifier.tail(3))

# 데이터 타입 확인
print(data_Regression.info())
print("==========================================")
print(data_Classifier.info())

# 기술 통계 확인
print(data_Regression.describe())
print("=================================================================================")
print(data_Classifier.describe())

# 상관관계 확인
display(data_Regression.corr(numeric_only=True))
display(data_Classifier.corr(numeric_only=True))

1. 데이터 전처리

Regression(회귀) : 보스턴의 집 값 예측

Classifier(분류) : 타이타닉에 승선한 승객의 생존 여부

1-1. 데이터 전처리

1-1-1. 보스턴 집 값 데이터(회귀용) 데이터 전처리

해당 데이터는 데이터 분리 이외의 전처리가 필요하지 않음.

1-1-2. 타이타닉 승객 데이터(분류용) 데이터 전처리

# 결측치 처리 : Age 결측치를 중앙값으로 채우기
age_median = data_Classifier['Age'].median()
data_Classifier['Age'].fillna(age_median, inplace=True)

# 제거 대상: PassengerId, Name, Ticket, Cabin
titanic_drop_cols = ['PassengerId', 'Name', 'Ticket', 'Cabin']

# 변수 제거
data_Classifier.drop(titanic_drop_cols, axis=1, inplace=True)

# 가변수화 대상: Pclass, Sex, Embarked
dumm_cols = ['Pclass', 'Sex', 'Embarked']

# 가변수화
data_Classifier = pd.get_dummies(data_Classifier, columns=dumm_cols, drop_first=True, dtype=int)

# 확인
data_Classifier.head()

1-2. target 확인 및 데이터 분리

# 보스턴의 집 값: Target
target_Regression = "medv"

x_Regression = data_Regression.drop(target_Regression, axis=1)
y_Regression = data_Regression.loc[:, target_Regression]

# 타이타닉에 승선한 승객의 생존 여부: Target
target_Classifier = "Survived"

x_Classifier = data_Classifier.drop(target_Classifier, axis=1)
y_Classifier = data_Classifier.loc[:, target_Classifier]

1-3. 학습용, 평가용 데이터 분리

# 모듈 불러오기
from sklearn.model_selection import train_test_split

# 7(학습용):3(평가용)으로 분리
x_Regre_train, x_Regre_test, y_Regre_train, y_Regre_test = train_test_split(x_Regression, y_Regression, test_size=0.3, random_state=1)
x_Classi_train, x_Classi_test, y_Classi_train, y_Classi_test = train_test_split(x_Classifier, y_Classifier, test_size=0.3, random_state=1, stratify = y_Classifier)

1-4.정규화_일부 모델의 경우 필요

# 정규화 모듈 불러오기
from sklearn.preprocessing import MinMaxScaler

# 정규화
scaler_MinMaxScaler = MinMaxScaler()
scaler_MinMaxScaler.fit(x_Regre_train)
x_MinMaxScaler_train = scaler_MinMaxScaler.transform(x_Regre_train)
x_MinMaxScaler_test = scaler_MinMaxScaler.transform(x_Regre_test)

2. 모델별 정리

1. Linear Regression_선형 회귀 (회귀)

#모델 불러오기
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error, r2_score

#모델 선언
model_LinearRegression = LinearRegression()

#모델 학습
model_LinearRegression.fit(x_Regre_train, y_Regre_train)

#모델 예측
y_pred_LinearRegression = model_LinearRegression.predict(x_Regre_test)

#모델 평가
print("MAE(mean_absolute_error) : ",mean_absolute_error(y_Regre_test, y_pred_LinearRegression))
print("R2-Score : ", r2_score(y_Regre_test, y_pred_LinearRegression))

2. K-Nearest Neighbor_KNN (회귀)

#모델 불러오기
from sklearn.neighbors import KNeighborsRegressor
from sklearn.metrics import mean_absolute_error, r2_score

#모델 선언
model_KNeighborsRegressor = KNeighborsRegressor()

#모델 학습
model_KNeighborsRegressor.fit(x_MinMaxScaler_train, y_Regre_train)

#모델 예측
y_pred_KNeighborsRegressor = model_KNeighborsRegressor.predict(x_MinMaxScaler_test)

#모델 평가
print('MAE(mean_absolute_error):', mean_absolute_error(y_Regre_test, y_pred_KNeighborsRegressor))
print('R2-Score:', r2_score(y_Regre_test, y_pred_KNeighborsRegressor))

3. K-Nearest Neighbor_KNN (분류)

#모델 불러오기
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import confusion_matrix, classification_report

#모델 선언
model_KNeighborsClassifier = KNeighborsClassifier()

#모델 학습
model_KNeighborsClassifier.fit(x_Classi_train, y_Classi_train)

#모델 예측
y_pred_KNeighborsClassifier = model_KNeighborsClassifier.predict(x_Classi_test)

#모델 평가
print(confusion_matrix(y_Classi_test, y_pred_KNeighborsClassifier))
print(classification_report(y_Classi_test, y_pred_KNeighborsClassifier))

4. Decision Trees_결정 트리 (회귀)

#모델 불러오기
from sklearn.tree import DecisionTreeRegressor
from sklearn.metrics import mean_absolute_error, r2_score

#모델 선언
model_DecisionTreeRegressor = DecisionTreeRegressor(max_depth=5, random_state=1)

#모델 학습
model_DecisionTreeRegressor.fit(x_Classi_train, y_Classi_train)

#모델 예측
y_pred_DecisionTreeRegressor = model_DecisionTreeRegressor.predict(x_Classi_test)

#모델 평가
print('MAE(mean_absolute_error):', mean_absolute_error(y_Regre_test, y_pred_KNeighborsRegressor))
print('R2-Score:', r2_score(y_Regre_test, y_pred_KNeighborsRegressor))

5. Decision Trees_결정 트리 (분류)

#모델 불러오기
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import confusion_matrix, classification_report

#모델 선언
model_DecisionTreeClassifier = DecisionTreeClassifier(max_depth=5, random_state=1)

#모델 학습
model_DecisionTreeClassifier.fit(x_Classi_train, y_Classi_train)

#모델 예측
y_pred_DecisionTreeClassifier = model_DecisionTreeClassifier.predict(x_Classi_test)

#모델 평가
print(confusion_matrix(y_Classi_test, y_pred_DecisionTreeClassifier))
print(classification_report(y_Classi_test, y_pred_DecisionTreeClassifier))

6. Logistic Regression_로지스틱 회귀 (분류)

#모델 불러오기
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix, classification_report

#모델 선언
model_LogisticRegression = LogisticRegression()

#모델 학습
model_LogisticRegression.fit(x_Classi_train, y_Classi_train)

#모델 예측
y_pred_LogisticRegression = model_LogisticRegression.predict(x_Classi_test)

#모델 평가
print(confusion_matrix(y_Classi_test, y_pred_LogisticRegression))
print(classification_report(y_Classi_test, y_pred_LogisticRegression))

7. RandomForest : 랜덤 포레스트 (분류)

# 여기에 답안코드를 작성하세요.
from sklearn.ensemble import RandomForestClassifier

#모델 선언
model_RandomForestClassifier = RandomForestClassifier() 

#모델 학습
model_RandomForestClassifier.fit(x_Classi_train, y_Classi_train)

#모델 예측
y_pred_RandomForestClassifier = model_RandomForestClassifier.predict(x_Classi_test)

#모델 평가
print(confusion_matrix(y_Classi_test, y_pred_RandomForestClassifier))
print(classification_report(y_Classi_test, y_pred_RandomForestClassifier))

8. RandomForest : 랜덤 포레스트 (회귀)

# 여기에 답안코드를 작성하세요.
from sklearn.ensemble import RandomForestRegressor

#모델 선언
model_RandomForestRegressor = RandomForestRegressor() 

#모델 학습
model_RandomForestRegressor.fit(x_Regre_train, y_Regre_train)

#모델 예측
y_pred_RandomForestRegressor = model_RandomForestRegressor.predict(x_Regre_test)

#모델 평가
print('MAE(mean_absolute_error):', mean_absolute_error(y_Regre_test, y_pred_RandomForestRegressor))
print('R2-Score:', r2_score(y_Regre_test, y_pred_RandomForestRegressor))

9. XGBoost_익스트림 그레이디언트 부스팅 : Extreme Gradient Boosting (분류)

#모델 불러오기
from xgboost import XGBClassifier

#모델 선언
model_XGBClassifier = XGBClassifier() 

#모델 학습
model_XGBClassifier.fit(x_Classi_train, y_Classi_train)

#모델 예측
y_pred_XGBClassifier = model_XGBClassifier.predict(x_Classi_test)

#모델 평가
print(confusion_matrix(y_Classi_test, y_pred_XGBClassifier))
print(classification_report(y_Classi_test, y_pred_XGBClassifier))

10. XGBoost_Extreme Gradient Boosting : 익스트림 그레이디언트 부스팅 (회귀)

#모델 불러오기
from xgboost import XGBRegressor

#모델 선언
model_XGBRegressor = XGBRegressor() 

#모델 학습
model_XGBRegressor.fit(x_Regre_train, y_Regre_train)

#모델 예측
y_pred_XGBRegressor = model_XGBRegressor.predict(x_Regre_test)

#모델 평가
print('MAE(mean_absolute_error):', mean_absolute_error(y_Regre_test, y_pred_XGBRegressor))
print('R2-Score:', r2_score(y_Regre_test, y_pred_XGBRegressor))

11. LGBM_Light Gradient Boosting Model : 라이트 그레이디언트 부스팅 (분류)

from lightgbm import LGBMClassifier

#모델 선언
model_LGBMClassifier = LGBMClassifier() 

#모델 학습
model_LGBMClassifier.fit(x_Classi_train, y_Classi_train)

#모델 예측
y_pred_LGBMClassifier = model_LGBMClassifier.predict(x_Classi_test)

#모델 평가
print(confusion_matrix(y_Classi_test, y_pred_LGBMClassifier))
print(classification_report(y_Classi_test, y_pred_LGBMClassifier))

x_Classi_train

12. LGBM_Light Gradient Boosting Model : 라이트 그레이디언트 부스팅 (회귀)

from lightgbm import LGBMRegressor

#모델 선언
model_LGBMRegressor = LGBMRegressor() 

#모델 학습
model_LGBMRegressor.fit(x_Regre_train, y_Regre_train)

#모델 예측
y_pred_LGBMRegressor = model_LGBMRegressor.predict(x_Regre_test)

#모델 평가
print('MAE(mean_absolute_error):', mean_absolute_error(y_Regre_test, y_pred_LGBMRegressor))
print('R2-Score:', r2_score(y_Regre_test, y_pred_LGBMRegressor))