[AI] pandas/sklearn을 활용한 머신러닝 모델링

본 글에서는 👉이전글에서 전처리된 데이터를 기반으로 선형회귀, 로지스틱 회귀, 의사결정나무 모델에 학습시키고 성능을 평가해볼 것입니다.

데이터 준비

• 샘플데이터 : boston.csv

1. 데이터 불러오기

# 라이브러리 불러오기
import pandas as pd

df = pd.read_csv("./data/boston.csv")

2. 데이터 분리
   : 모델의 Overfitting(과적합)을 방지하기 위해 학습용, 평가용, 검증용(Option) 데이터를 나누는 과정입니다.
   Overfitting(과적합) : 학습용(train) 데이터에 과도하게 적합해져서 새로운 데이터에 대한 예측력이 떨어지는 현상

# Feature는 x, Target은 y 로 저장합니다.
x = df.drop(columns=['MEDV'])
y = df['MEDV']

# sklearn 패키키 증 train_test_split 함수 불러오기
from sklearn.model_selection import train_test_split

# Feature와 Target을 train, test 데이터 셋으로 나누기
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=42)

지도학습 회귀 - 선형회귀

• 샘플데이터 : boston.csv

1. 데이터 불러오기

# 라이브러리 불러오기
import pandas as pd

df = pd.read_csv("./data/boston.csv")

2. 데이터 분리

# Feature는 x, Target은 y 로 저장합니다.
x = df.drop(columns=['MEDV'])
y = df['MEDV']

# sklearn 패키키 증 train_test_split 함수 불러오기
from sklearn.model_selection import train_test_split

# Feature와 Target을 train, test 데이터 셋으로 나누기
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=42)

3. 단순선형회귀 (Linear Regression)
   : 1개의 feature를 기반으로 수치를 예측하는 모델, 👉Linear Regression글 참고

# 라이브러리 호출
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

# 모델 선언
model = LinearRegression()

# 학습하기
model.fit(x_train[['RM']], y_train)

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

# 평가하기
print("MSE : ", mean_squared_error(y_test, y_pred))
# MSE(Mean Squared Error) : 평균제곱오차, 예측값과 실제값과의 차이를 제곱한 것의 평균
# 모델의 성능과 MSE는 반비례

# 선형회귀 분석 결과 시각화
# 회귀계수 확인
w = model.coef_
b = model.intercept_
print("기울기 : ", w)    # 기울기
print("절편 : ", b)     # 절편

# 선형회귀식
x = x_test[['RM']]
y = w * x + b

# 시각화
import matplotlib.pyplot as plt
plt.scatter(x_test[['RM']], y_test)
plt.plot(x, y, color='r')
plt.xlabel('RM')
plt.ylabel('MEDV')

plt.show()

# 예측값 실제값 비교
# 실제값과 예측값을 비교하기 위해 데이터프레임으로 만들기
df_lr = pd.DataFrame()
df_lr['y_test'] = y_test
df_lr['y_pred'] = y_pred
df_lr.reset_index(drop=True, inplace=True)

# 시각화
plt.plot(df_lr['y_test'], label='Actual')
plt.plot(df_lr['y_pred'], label='Predicted')
plt.legend()
plt.show()

• MSE (Mean Squared Error)
  

  

4. 다중선형회귀 (Linear Regression)
   : 다수의 feature를 기반으로 수치를 예측하는 모델, 👉Linear Regression글 참고

# 라이브러리 호출
from sklearn.linear_model import LinearRegression

# 모델 선언
model2 = LinearRegression()

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

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

# 평가하기
print("MSE : ", mean_squared_error(y_test, y_pred))

# 선형회귀 분석 결과 시각화
# 회귀계수 확인
w = model.coef_
b = model.intercept_
print("기울기 : ", w)    # 기울기
print("절편 : ", b)     # 절편

# 선형회귀식
formula = "MEDV = {:.2f}".format(b)
for i, feature_name in enumerate(x_test.columns):
    formula += " + {:.2f} * {}".format(w[i], feature_name)
print("선형회귀식: " + formula)

# 시각화
import matplotlib.pyplot as plt
plt.plot(y_test.values[:50], label='Actual')
plt.plot(y_pred[:50], label='Predicted')
plt.legend()
plt.show()

지도학습 분류

• 샘플데이터 : wine.csv

1. 데이터 불러오기

# 라이브러리 불러오기
import pandas as pd

df = pd.read_csv("./data/wine.csv")

2. 데이터 분리

# Feature는 x, Target은 y 로 저장합니다.
x = df.drop(columns=['class'])
y = df['class']

# sklearn 패키키 증 train_test_split 함수 불러오기
from sklearn.model_selection import train_test_split

# Feature와 Target을 train, test 데이터 셋으로 나누기
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=42)

3. 로지스틱 회귀 (Logistic Regression)
   : 다수의 feature를 기반으로 이진분류하는 모델, 👉Logistic Regression글 참고

# 라이브러리 호출
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

# 모델 선언
model = LogisticRegression()

# 이진분류를 위한 테스트데이터 세팅
x_train_b = x_train.loc[y_train[y_train !='class_2'].index]
y_train_b = y_train[y_train !='class_2']
x_test_b = x_test.loc[y_test[y_test !='class_2'].index]
y_test_b = y_test[y_test !='class_2']

# 학습하기
model.fit(x_train_b, y_train_b)

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

# 평가하기
print("accuracy : ", accuracy_score(y_test_b, y_pred))
# accuracy_score : 정확도를 계산하기 위한 sklearn패키지 함수 (예측결과가 동일한 데이터 건수 / 전체 예측 데이터 건수)

# 예측값 실제값 비교
# 실제값과 예측값을 비교하기 위해 데이터프레임으로 만들기
df_result = pd.DataFrame()
df_result['y_test_b'] = y_test_b
df_result['y_pred'] = y_pred
df_result.reset_index(drop=True, inplace=True)

4. 소프트맥스 회귀 (Softmax Regression)
   : 다수의 feature를 기반으로 다중분류하는 모델, 👉Softmax Regression글 참고

# 라이브러리 호출
from sklearn.linear_model import LogisticRegression

# 모델 선언
model_softmax = LogisticRegression(multi_class='multinomial')

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

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

# 평가하기
print("accuracy : ", accuracy_score(y_test, y_pred))

# 예측값 실제값 비교
# 실제값과 예측값을 비교하기 위해 데이터프레임으로 만들기
df_result = pd.DataFrame()
df_result['y_test'] = y_test
df_result['y_pred'] = y_pred
df_result.reset_index(drop=True, inplace=True)

지도학습 - 의사결정나무

: 의사결정나무 모델은 아래 그림처럼 여러 target으로 분기하는 과정에서 여러 기준에 의거하여 데이터를 분류하거나 결과값을 예측하는 모델
학습을 통해 기준 수치를 조정하여 모델을 일반화하게 되고, 회귀/분류 모델로서 활용 가능합니다.
아래 그림은 outlook, humidity, windy 기준으로 경기가 열릴지 안열리지를 판단하는 모델을 도식화한 그림입니다.

• reference : https://ratsgo.github.io/machine%20learning/2017/03/26/tree/

• 샘플데이터 : wine.csv, boston.csv

1. 데이터 불러오기

# 라이브러리 불러오기
import pandas as pd

df = pd.read_csv("./data/wine.csv"

2. 데이터 분리

# Feature는 x, Target은 y 로 저장합니다.
x = df.drop(columns=['class'])
y = df['class']

# sklearn 패키키 증 train_test_split 함수 불러오기
from sklearn.model_selection import train_test_split

# Feature와 Target을 train, test 데이터 셋으로 나누기
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=42)

3. 의사결정나무 - 분류

# 라이브러리 호출
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

# 모델 선언
model = DecisionTreeClassifier()

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

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

# 평가하기
print("accuracy : ", accuracy_score(y_test, y_pred))

# 의사결정나무(Decision Tree) 구조 보기
# 시각화 모듈 불러오기
from sklearn.tree import export_graphviz

# 이미지 파일 만들기
export_graphviz(model,                        # 모델이름
                out_file='tree_wine.dot',
                feature_names=x.columns,      # Feature 이름
                class_names=y.unique(),       # Target Class 이름
                rounded=True, 
                precision = 3, 
                filled = True)
!dot -Tpng tree_wine.dot -o tree_wine.png -Gdpi=300

# 이미지 파일 로딩
from IPython.display import Image
Image(filename='tree_wine.png', width=600)        # 사이즈 조정

# 예측값 실제값 비교
# 실제값과 예측값을 비교하기 위해 데이터프레임으로 만들기
df_result = pd.DataFrame()
df_result['y_test'] = y_test
df_result['y_pred'] = y_pred
df_result.reset_index(drop=True, inplace=True)

4. 의사결정나무 - 회귀

# 데이터 불러오기
df = pd.read_csv("./data/boston.csv")

# 데이터 분리
# Feature는 x, Target은 y 로 저장합니다.
x = df.drop(columns=['MEDV'])
y = df['MEDV']

# sklearn 패키키 증 train_test_split 함수 불러오기
from sklearn.model_selection import train_test_split

# Feature와 Target을 train, test 데이터 셋으로 나누기
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=42)



# 라이브러리 호출
from sklearn.tree import DecisionTreeRegressor
from sklearn.metrics import mean_squared_error

# 모델 선언
model = DecisionTreeRegressor()

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

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

# 평가하기
print("MSE : ", mean_squared_error(y_test, y_pred))

# 의사결정나무(Decision Tree) 구조 보기
# 시각화 모듈 불러오기
from sklearn.tree import export_graphviz

# 이미지 파일 만들기
export_graphviz(model,                        # 모델이름
                max_depth=5,
                out_file='tree_boston.dot',
                feature_names=x.columns,      # Feature 이름
                rounded=True, 
                precision = 3, 
                filled = True)
!dot -Tpng tree_boston.dot -o tree_boston.png -Gdpi=300

# 이미지 파일 로딩
from IPython.display import Image
Image(filename='tree_boston.png', width=600)        # 사이즈 조정

# 예측값 실제값 비교
# 실제값과 예측값을 비교하기 위해 데이터프레임으로 만들기
df_result = pd.DataFrame()
df_result['y_test'] = y_test
df_result['y_pred'] = y_pred
df_result.reset_index(drop=True, inplace=True)

# 시각화
plt.plot(y_test.values[:50], label='Actual')
plt.plot(y_pred[:50], label='Predicted')
plt.legend()
plt.show()

예측과 성능 평가

• 샘플데이터 : boston.csv, wine.csv

1. 데이터 불러오기

# 라이브러리 불러오기
import pandas as pd
import matplotlib.pyplot as plt

df = pd.read_csv("./data/boston.csv")

2. 데이터 분리

# Feature는 x, Target은 y 로 저장합니다.
x = df.drop(columns=['MEDV'])
y = df['MEDV']

# sklearn 패키키 증 train_test_split 함수 불러오기
from sklearn.model_selection import train_test_split

# Feature와 Target을 train, test 데이터 셋으로 나누기
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=42)

3. 회귀모델 성능 평가

# 라이브러리 호출
from sklearn.linear_model import LinearRegression
from sklearn.tree import DecisionTreeRegressor
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score

# 모델 선언
model_lr = LinearRegression()
model_dt = DecisionTreeRegressor()

# 모델 학습
model_lr.fit(x_train, y_train)
model_dt.fit(x_train, y_train)

# 예측하기
y_pred_lr = model_lr.predict(x_test)
y_pred_dt = model_dt.predict(x_test)

# 평가하기
print("LinearRegression 모델")
print("MSE : ", mean_squared_error(y_test, y_pred_lr))
print("RMSE :", mean_squared_error(y_test, y_pred_lr)**(1/2))
print("MAE : ", mean_absolute_error(y_test, y_pred_lr))
print("R2 Score : ", r2_score(y_test, y_pred_lr))
print("")
print("DecisionTreeRegressor 모델")
print("MSE : ", mean_squared_error(y_test, y_pred_dt))
print("RMSE :", mean_squared_error(y_test, y_pred_dt)**(1/2))
print("MAE : ", mean_absolute_error(y_test, y_pred_dt))
print("R2 Score : ", r2_score(y_test, y_pred_dt))

# R2_Score (결정계수) = SSR/SST = 1 - SSE/SST, 해당 수치가 클 수록 회귀 모델의 성능이 높음
# SST (Total Sum of Squares) : 실제값에서 실제값의 평균을 뺀 차이의 제곱을 모두 합한 수치
# SSR (Sum of Squares due to Regression) : 예측값에서 실제값의 평균을 뺀 차이의 제곱을 모두 합한 수치
# SSE (Sum of Squares Residual of Error) : 실제값에서 예측값을 뺀 차이의 제곱을 모두 합한 수치

• SST/SSR/SSE
  

  

4. 분류모델 성능 평가

# 데이터 불러오기
df = pd.read_csv("./data/wine.csv")

# 데이터 분리
# Feature는 x, Target은 y 로 저장합니다.
x = df.drop(columns=['class'])
y = df['class']

# sklearn 패키키 증 train_test_split 함수 불러오기
from sklearn.model_selection import train_test_split

# Feature와 Target을 train, test 데이터 셋으로 나누기
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=42)

# 라이브러리 호출
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import confusion_matrix, precision_score, recall_score, accuracy_score, f1_score, classification_report

# 모델 선언
model_lr = LogisticRegression()
model_dt = DecisionTreeClassifier()

# 모델 학습
model_lr.fit(x_train, y_train)
model_dt.fit(x_train, y_train)

# 예측하기
y_pred_lr = model_lr.predict(x_test)
y_pred_dt = model_dt.predict(x_test)

# 평가하기
print("LogisticRegression 모델")
print("Precision : ", precision_score(y_test, y_pred_lr, average='macro'))
print("Recall :", recall_score(y_test, y_pred_lr, average='macro'))
print("Accuracy : ", accuracy_score(y_test, y_pred_lr))
print("F1 Score : ", f1_score(y_test, y_pred_lr, average='macro'))
print("")
print("DecisionTreeClassifier 모델")
print("Precision : ", precision_score(y_test, y_pred_dt, average='macro'))
print("Recall :", recall_score(y_test, y_pred_dt, average='macro'))
print("Accuracy : ", accuracy_score(y_test, y_pred_dt))
print("F1 Score : ", f1_score(y_test, y_pred_dt, average='macro'))

# precision_score : 정밀도, 모델이 1이라고 예측한 것중에 실제로 1인 것의 정도
# accuracy_score : 정확도, 모델이 예측한 값과 실제 값이 일치하는 정도
# recall_score : 재현율, 실제로 1인 것중에 모델이 1이라고 예측한 비율
# f1_score : 정밀도와 회수율을 고르게 활용하기 위한 조화평균, 1에 가까울수록 성능이 좋음

• Precision/Recall
  

  

  
  
  
  

Cross Validation (교차 검증)

: 데이터를 train set과 test set으로 나누는 방식에서 train set을 train set + validation set으로 추가로 나누어 검증하는 방식
데이터를 train set과 test set으로 나누고, test set을 활용하여 모델의 성능을 검증 및 개선 과정을 반복하면 모델이 test set 과적합(overfitting)될 우려가 있음. 이를 방지하기 위해 교차 검증으로 모델의 성능 검증 및 개선을 진행함.

• 샘플데이터 : boston.csv, wine.csv

1. 데이터 불러오기

# 라이브러리 불러오기
import pandas as pd
import matplotlib.pyplot as plt

df = pd.read_csv("./data/boston.csv")

# Feature는 x, Target은 y 로 저장합니다.
x = df.drop(columns=['MEDV'])
y = df['MEDV']

2. 회귀모델 교차검증

# 라이브러리 호출
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import cross_val_score

# 모델 선언하기
model_lr = LinearRegression()
model_dt = DecisionTreeRegressor()

# 학습, 예측, 평가하기
lr_cv_score = cross_val_score(model_lr, x, y, cv=10, scoring='neg_mean_squared_error')    
dt_cv_score = cross_val_score(model_dt, x, y, cv=10, scoring='neg_mean_squared_error')    # cv는 위 사진에서 Fold의 갯수를 가리킴

# 결과 확인
# 확인
print("LinearRegression 모델")
print(lr_cv_score)
print("MSE : ", -lr_cv_score.mean())
print("DecisionTreeRegressor 모델")
print(dt_cv_score)
print("MSE : ", -dt_cv_score.mean())

3. 분류모델 교차검증

# 데이터 불러오기
df = pd.read_csv("./data/wine.csv")

# Feature는 x, Target은 y 로 저장합니다.
x = df.drop(columns=['class'])
y = df['class']

# 라이브러리 호출
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import cross_val_score

# 모델 선언하기
model_lr = LogisticRegression()
model_dt = DecisionTreeClassifier()

# 학습, 예측, 평가하기
lr_cv_score = cross_val_score(model_lr, x, y, cv=5, scoring='f1_macro')
dt_cv_score = cross_val_score(model_dt, x, y, cv=5, scoring='f1_macro')

# 결과 확인
# 확인
print("LogisticRegression 모델")
print(lr_cv_score)
print("F1 Score : ", lr_cv_score.mean())
print("DecisionTreeClassifier 모델")
print(dt_cv_score)
print("F1 Score : ", dt_cv_score.mean())