4 P1 실습: 머신러닝 프로젝트

import sys
import sklearn
from packaging.version import Version

# 파이썬 버전과 scikit-learn 버전 확인
assert sys.version_info >= (3, 10)
assert Version(sklearn.__version__) >= Version("1.6.1")

# 필요한 라이브러리 임포트
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# 그래프 스타일 설정
plt.rc('font', size=12)
plt.rc('axes', labelsize=14, titlesize=14)
plt.rc('legend', fontsize=12)
plt.rc('xtick', labelsize=10)
plt.rc('ytick', labelsize=10)

import pandas as pd

url = "https://raw.githubusercontent.com/codingalzi/code-workout-ml/master/datasets/housing/housing.csv"
housing_full = pd.read_csv(url)

housing_full.head()

housing_full.info()

housing_full["ocean_proximity"].value_counts()

housing_full.describe()

housing_full.hist(bins=50, figsize=(12, 8))

plt.show()

from sklearn.model_selection import train_test_split

train_set, test_set = train_test_split(housing_full, test_size=0.2,
                                       random_state=42)

housing_full['median_income'].hist()
plt.show()

housing_full["income_cat"] = pd.cut(housing_full["median_income"],
                                    bins=[0., 1.5, 3.0, 4.5, 6., np.inf],
                                    labels=[1, 2, 3, 4, 5])

cat_counts = housing_full["income_cat"].value_counts().sort_index()
cat_counts.plot.bar(rot=0, grid=True)
plt.xlabel("Income category")
plt.ylabel("Number of districts")

plt.show()

strat_train_set, strat_test_set = train_test_split(
    housing_full, 
    test_size=0.2,
    stratify=housing_full["income_cat"],            # 층화 샘플링을 위한 기준이 되는 열 지정
    random_state=42)

for set_ in (strat_train_set, strat_test_set):
    set_.drop("income_cat", axis=1, inplace=True)

housing_train = strat_train_set.copy()

housing_train.shape

corr_matrix = housing_train.corr(numeric_only=True)

import seaborn as sns
sns.heatmap(corr_matrix, 
            annot=True, 
            fmt=".2f", 
            cmap="coolwarm",
            annot_kws={"size": 9})
plt.show()

housing_train.plot(kind="scatter", x="median_income", y="median_house_value",
             alpha=0.1, grid=True)

plt.show()

# 훈련셋 (입력 데이터셋)
X_train = housing_train.drop("median_house_value", axis=1)

# 타깃셋
y_train = housing_train["median_house_value"].copy()

from sklearn.impute import SimpleImputer

imputer = SimpleImputer(strategy="median")

from sklearn.preprocessing import OneHotEncoder

cat_encoder = OneHotEncoder()

from sklearn.preprocessing import MinMaxScaler

min_max_scaler = MinMaxScaler(feature_range=(-1, 1))

from sklearn.preprocessing import StandardScaler

std_scaler = StandardScaler()

from sklearn.preprocessing import FunctionTransformer

log_transformer = FunctionTransformer(np.log)

# extra code – this cell generates Figure 2–17
fig, axs = plt.subplots(1, 2, figsize=(8, 3), sharey=True)

X_train["population"].hist(ax=axs[0], bins=50)

log_pop = log_transformer.transform(X_train[["population"]])
log_pop.hist(ax=axs[1], bins=50)

axs[0].set_xlabel("Population")
axs[1].set_xlabel("Log of population")
axs[0].set_ylabel("Number of districts")

plt.show()

from sklearn.pipeline import Pipeline

default_num_pipeline = Pipeline([
    ("impute", SimpleImputer(strategy="median")),
    ("standardize", StandardScaler()),
    ])

from sklearn.pipeline import make_pipeline

default_num_pipeline = make_pipeline(SimpleImputer(strategy="median"), 
                                     StandardScaler())

from sklearn.compose import ColumnTransformer

# 수치형 특성 리스트 지정
num_attribs = ["longitude", "latitude", "housing_median_age", "total_rooms",
               "total_bedrooms", "population", "households", "median_income"]
# 범주형 특성 리스트 지정
cat_attribs = ["ocean_proximity"]

# 범주형 특성 변환 파이프라인
cat_pipeline = make_pipeline(
    SimpleImputer(strategy="most_frequent"),
    OneHotEncoder(handle_unknown="ignore"))

log_pipeline = make_pipeline(
    SimpleImputer(strategy="median"),
    FunctionTransformer(np.log, feature_names_out="one-to-one"),
    StandardScaler())

from sklearn.compose import make_column_selector

preprocessing = ColumnTransformer([
        ("log", log_pipeline, ["total_bedrooms", "total_rooms", "population",
                               "households", "median_income"]),
        ("cat", cat_pipeline, make_column_selector(dtype_include=object)),
        ],
        remainder=default_num_pipeline # 남은 특성 하나: housing_median_age
        )

X_train_arr = preprocessing.fit_transform(X_train)

X_train_arr.shape

preprocessing.get_feature_names_out()

X_train_df = pd.DataFrame(X_train_arr,
                          columns=preprocessing.get_feature_names_out(),
                          index=X_train.index)
X_train_df.head()

X_train_df.info()

from sklearn.linear_model import LinearRegression

lin_reg = LinearRegression()
lin_reg.fit(X_train_df, y_train)

from sklearn.metrics import root_mean_squared_error

housing_predictions_lin = lin_reg.predict(X_train_df)
lin_rmse = root_mean_squared_error(y_train, housing_predictions_lin)
lin_rmse

from sklearn.tree import DecisionTreeRegressor

tree_reg = DecisionTreeRegressor(random_state=42)
tree_reg.fit(X_train_df, y_train)

housing_predictions_tree = tree_reg.predict(X_train_df)
tree_rmse = root_mean_squared_error(y_train, housing_predictions_tree)
tree_rmse

from sklearn.ensemble import RandomForestRegressor

forest_reg = RandomForestRegressor(n_estimators=100, random_state=42)
forest_reg.fit(X_train_df, y_train)

housing_predictions_forest = forest_reg.predict(X_train_df)
forest_rmse = root_mean_squared_error(y_train, housing_predictions_forest)
forest_rmse

from sklearn.model_selection import cross_val_score

lin_rmses = -cross_val_score(lin_reg, X_train_df, y_train,
                              scoring="neg_root_mean_squared_error", cv=5)

lin_rmses

lin_rmses.mean()

tree_rmses = -cross_val_score(tree_reg, X_train_df, y_train,
                              scoring="neg_root_mean_squared_error", cv=5)
tree_rmses.mean()

forest_rmses = -cross_val_score(forest_reg, X_train_df, y_train,
                                scoring="neg_root_mean_squared_error", cv=5)

forest_rmses.mean()

from sklearn.model_selection import GridSearchCV

# 랜덤 포레스트 기본 모델
forest_reg_base = RandomForestRegressor(random_state=42)

# 하이퍼파라미터 조합: 3*3 + 2*3 조합 확인
# 랜덤 포레스트 모델의 트리 개수(n_estimators)와 최대 특성 수(max_features) 대상 지정
param_grid = [
    {'n_estimators': [50, 100, 150],   # 트리 개수
     'max_features': [4, 6, 8]},       # 최대 특성 수
    {'n_estimators': [100, 200],
     'max_features': [8, 10, 12]},
]

# 그리드 탐색 객체 생성: 전체 파이프라인과 하이퍼파라미터 그리드, 교차 검증 분할 수, 평가 지표 지정
grid_search = GridSearchCV(forest_reg_base, 
                           param_grid, 
                           cv=3,
                           scoring='neg_root_mean_squared_error')

# 그리드 탐색 수행
grid_search.fit(X_train_df, y_train)

grid_search.best_params_

grid_search.best_estimator_

-grid_search.best_score_

from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint

# 랜덤 탐색을 위한 하이퍼파라미터 분포 지정:
# - 트리 개수는 50~300 범위에서 균등 분포로 샘플링
# - 최대 특성 수는 2~20 범위에서 균등 분포로 샘플링
param_distribs = {'n_estimators': randint(low=50, high=300),
                  'max_features': randint(low=2, high=20)}

# 랜덤 탐색 객체 생성: 전체 파이프라인과 하이퍼파라미터 분포, 교차 검증 분할 수, 평가 지표 지정
rnd_search = RandomizedSearchCV(forest_reg_base,
                                param_distributions=param_distribs, 
                                n_iter=10, 
                                cv=3,
                                scoring='neg_root_mean_squared_error', 
                                random_state=42)

# 랜덤 탐색 수행
rnd_search.fit(X_train_df, y_train)

rnd_search.best_params_

rnd_search.best_estimator_

-rnd_search.best_score_

final_model = rnd_search.best_estimator_