Python/머신러닝(ML)

Python(26)- 다양한 모델 적용

두설날 2024. 6. 19. 08:50

*이 글을 읽기전에 작성자 개인의견이 있으니, 다른 블로그와 교차로 읽는것을 권장합니다.*

1. AirQualityUCI 데이터셋

 
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
air_df = pd.read_csv('/content/drive/MyDrive/KDT/6. 머신러닝과 딥러닝/Data/AirQualityUCI.csv')
air_df

air_df.info()

  • Date: 측정 날짜
  • Time: 측정 시간
  • CO(GT): 일산화탄소 농도 (mg/m^3)
  • PT08.S1(CO): 일산화탄소에 대한 센서 응답
  • NMHC(GT): 비메탄 탄화수소 농도 (microg/m^3)
  • C6H6(GT): 벤젠 농도 (microg/m^3)
  • PT08.S2(NMHC): 탄화수소에 대한 센서 응답
  • NOx(GT): 산화 질소 농도 (ppb)
  • PT08.S3(NOx): 산화 질소에 대한 센서 응답
  • NO2(GT): 이산화질소 농도 (microg/m^3)
  • PT08.S4(NO2): 이산화질소에 대한 센서 응답
  • PT08.S5(O3): 오존에 대한 센서 응답
  • T: 온도 (°C)
  • RH: 상대 습도 (%)
  • AH: 절대 습도 (g/m^3)
air_df.drop(['Unnamed: 15', 'Unnamed: 16'], axis=1, inplace=True)
air_df.dropna(inplace=True)
air_df.info()

# Date 컬럼의 타입을 datetime 으로 변경
air_df['Date'] = pd.to_datetime(air_df.Date, format='%d-%m-%Y')
air_df.head()

air_df.info()

# Date column에 의한 Month 파생변수를 생성
air_df['Month'] = air_df['Date'].dt.month
air_df.head()

# Time column에 의한 Hour 파생변수를 생성
air_df['Hour'] = air_df['Time'].str.split(':').str[0].fillna(0).astype(int)
air_df.head()

# Date와 Time column을 제거
air_df.drop(['Date', 'Time'], axis=1, inplace=True)
air_df.info()

plt.figure(figsize=(12, 12))
sns.heatmap(air_df.corr(), cmap='coolwarm', vmax=1, vmin=-1, annot=True)
plt.show()

# 종속변수(RH)를 제외한 모든 컬럼을 StandarScaler로 정규화
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error
ss = StandardScaler()

X = air_df.drop('RH', axis=1)
y = air_df['RH']

Xss = ss.fit_transform(X)
Xss
X_train, X_test, y_train, y_test = train_test_split(Xss, y, test_size=0.2, random_state=2024)
X_train.shape, y_train.shape

X_test.shape, y_test.shape

2. 모델별 성능 확인하기

# RMSE로 확인하기

MSE


# Linear Regression (선형회귀)
# Decision Tree Regression (의사결정나무 회귀)
# Random Forest Regression (랜덤포레스트 회귀)
# Support Vector Machine Regression (서포트벡터머신 회귀)
# lightGBM (LightGBM)

# 어떤 모델이 현재 데이터에 가장 적합한가?

my_predictions = {}

colors = ['r', 'c', 'm', 'y', 'k', 'khaki', 'teal', 'orchid', 'sandybrown',
          'greenyellow', 'dodgerblue', 'deepskyblue', 'rosybrown', 'firebrick',
          'deeppink', 'crimson', 'salmon', 'darkred', 'olivedrab', 'olive',
          'forestgreen', 'royalblue', 'indigo', 'navy', 'mediumpurple', 'chocolate',
          'gold', 'darkorange', 'seagreen', 'turquoise', 'steelblue', 'slategray',
          'peru', 'midnightblue', 'slateblue', 'dimgray', 'cadetblue', 'tomato']

예측 값과 실제 값 비교해주는 시각화 함수 만들기

def plot_predictions(name_, pred, actual):
  df = pd.DataFrame({'prediction': pred, 'actual': y_test})
  df = df.sort_values(by='actual').reset_index(drop=True)

  plt.figure(figsize=(12, 9))
  # 예측값 산점도
  plt.scatter(df.index, df['prediction'], marker='x', color='r')
  # 실제값 산점도
  plt.scatter(df.index, df['actual'], alpha=0.7, marker='o', color='black')
  plt.title(name_, fontsize=15)
  # 범례 추가
  plt.legend(['prediction', 'actual'], fontsize=12)
  plt.show()
def mse_eval(name_, pred, actual):
# 전역변수 선언
  global my_predictions # 모델 저장
  global colors # 색상

# 위 시각화 함수 호출
  plot_predictions(name_, pred, actual)

# mse 계산
  mse = mean_squared_error(pred, actual)
  my_predictions[name_] = mse

# 예측값 내림차순 정렬
  y_value = sorted(my_predictions.items(), key=lambda x: x[1], reverse=True)

  df = pd.DataFrame(y_value, columns=['model', 'mse'])
  print(df)

# 최소값, 최대값 범위 설정
  min_ = df['mse'].min() - 10
  max_ = df['mse'].max() + 10
  length = len(df)

# subplot 막대그래프 출력
  plt.figure(figsize=(10, length))
  ax = plt.subplot()
  ax.set_yticks(np.arange(len(df))) # y축 길이설정
  ax.set_yticklabels(df['model'], fontsize=15)
  bars = ax.barh(np.arange(len(df)), df['mse'])

  for i, v in enumerate(df['mse']):
    idx = np.random.choice(len(colors)) # 색깔 랜덤
    bars[i].set_color(colors[idx]) 
    ax.text(v + 2, i, str(round(v, 3)), color='k', fontsize=15, fontweight='bold')

  plt.title('MSE Error', fontsize=18)
  plt.xlim(min_, max_) # x축 범위 min_ ~ max_ 설정

  plt.show()

2-1. Linear Regression

from sklearn.linear_model import LinearRegression
# 선형회귀모델 저장
model = LinearRegression()
# 훈련
model.fit(X_train, y_train)

# 예측값
pred1 = model.predict(X_test)
pred1

# RMSE 출력
rs1 = np.sqrt(mean_squared_error(y_test, pred1))
rs1

mse_eval('LinearRegression', pred1, y_test)

선형회귀 MSE값 = 50.987

2-2. Decision Tree Regression

from sklearn.tree import DecisionTreeRegressor
# 의사결정나무
model2 = DecisionTreeRegressor()
# 훈련
model2.fit(X_train, y_train)

pred2 = model2.predict(X_test)
pred2

rs2 = np.sqrt(mean_squared_error(y_test, pred2))
rs2
mse_eval('Decision Tree Regression', pred2, y_test)

Decision Tree Regression mse값 =1.53

2-3. Random Forest Regression

from sklearn.ensemble import RandomForestRegressor
model3 = RandomForestRegressor()
model3.fit(X_train, y_train)

pred3 = model3.predict(X_test)
pred3

rs3 = np.sqrt(mean_squared_error(y_test, pred3))
rs3

mse_eval('Random Forest Regression', pred3, y_test)

Random Forest Regression MSE값 = 0.389

2-4. Support Vector Machine

from sklearn.svm import SVR
model4 = SVR()
model4.fit(X_train, y_train)

pred4 = model4.predict(X_test)
pred4

rs4 = np.sqrt(mean_squared_error(y_test, pred4))
rs4

mse_eval('Supprt Vector Machine', pred4, y_test)

2-5. lightGBM

from lightgbm import LGBMRegressor
model5 = LGBMRegressor(randome_state=2024)
model5.fit(X_train, y_train)

pred5 = model5.predict(X_test)
pred5

rs5 = np.sqrt(mean_squared_error(y_test, pred5))
rs5

mse_eval('lightGBM', pred5, y_test)

SupportVectorMachine MSE값 = 397.884

dic = {'LinearRegression': rs1,
       'Decision Tree Regression': rs2,
       'Random Forest Regression': rs3,
       'Support Vector Machine': rs4,
       'lightGBM': rs5}

res = [key for key in dic if all(dic[temp] >= dic[key] for temp in dic)]
print(res)
min = {k: dic[k] for k in dic.keys() & set(res)}
print(min)

dic

결론 : SVM의 MSE값이 가장 크고, 랜덤포레스트값의 MSE값이 가장 작으므로 랜덤포레스트 결과 채택.

```
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=2024)
models = {
    "Linear Regression": LinearRegression(),
    "Decision Tree": DecisionTreeRegressor(),
    "Random Forest": RandomForestRegressor(),
    "Gradient Boosting": GradientBoostingRegressor()
}
# Train and evaluate the models
results = {}
for name, model in models.items():
    model.fit(X_train, y_train)
    predictions = model.predict(X_test)
    mse = mean_squared_error(y_test, predictions)
    results[name] = mse
results
```