ch2 - 머신러닝 프로젝트 처음부터 끝까지

데이터가 담고있는 정보:

• 블록 그룹(block group, 혹은 구역)마다 인구(population)

• 중간 소득(median income)

• 중간 주택 가격(median housing price)

• etc…

크게 아래와 같이 진행 예정

1. 큰 그림 보기

2. 데이터 구하기

3. 데이터로부터 패턴을 파악하기 위해 탐색 및 시각화

4. 머신러닝 알고리즘을 위한 데이터 준비

5. 모델 선택 및 훈련

6. 모델 상세히 조정

7. 솔루션(문제 해결 방법) 제시

8. 시스템 런칭 및 모니터링, 유지 보수

문제 정의

‘현재 문제 해결 방법은 어떻게 구성되어 있는가?’

• 머신러닝 모델이 사용되고 있지 않은 지금은 어떻게 문제를 해결하고 있는가 (참고용)

• ex) 현재 구역 별 중간 주택 가격 예측은 전문가가 수동으로 하고 있으며, 전문가의 추정 가격은 실제 주택 가격의 10% 정도가 벗어나는 문제가 있음.

• 이는 구역의 데이터를 기반으로 중간 주택 가격을 예측하는 모델을 훈련시키는 쪽이 유용할 듯 함.

성능 측정 지표 선택

이제 데이터를 구하여 가져와 보자

# 파이썬 2와 파이썬 3 지원from __future__ import division, print_function, unicode_literals# 공통import numpy as npimport os# 일관된 출력을 위해 유사난수 초기화np.random.seed(42)# 맷플롯립 설정%matplotlib inlineimport matplotlibimport matplotlib.pyplot as pltplt.rcParams['axes.labelsize'] = 14plt.rcParams['xtick.labelsize'] = 12plt.rcParams['ytick.labelsize'] = 12# 한글출력matplotlib.rc('font', family='NanumBarunGothic')plt.rcParams['axes.unicode_minus'] = False# 그림을 저장할 폴드PROJECT_ROOT_DIR = "."CHAPTER_ID = "end_to_end_project"IMAGES_PATH = os.path.join(PROJECT_ROOT_DIR, "images", CHAPTER_ID)def save_fig(fig_id, tight_layout=True, fig_extension="png", resolution=300):    path = os.path.join(IMAGES_PATH, fig_id + "." + fig_extension)    if tight_layout:        plt.tight_layout()    plt.savefig(path, format=fig_extension, dpi=resolution)

import osimport tarfilefrom six.moves import urllibDOWNLOAD_ROOT = "https://raw.githubusercontent.com/ageron/handson-ml/master/"HOUSING_PATH = os.path.join("datasets", "housing")HOUSING_URL = DOWNLOAD_ROOT + "datasets/housing/housing.tgz"def fetch_housing_data(housing_url=HOUSING_URL, housing_path=HOUSING_PATH):    if not os.path.isdir(housing_path):        os.makedirs(housing_path)    tgz_path = os.path.join(housing_path, "housing.tgz")    urllib.request.urlretrieve(housing_url, tgz_path)    housing_tgz = tarfile.open(tgz_path)    housing_tgz.extractall(path=housing_path)    housing_tgz.close()

fetch_housing_data()

import pandas as pddef load_housing_data(housing_path=HOUSING_PATH):    csv_path = os.path.join(housing_path, "housing.csv")    return pd.read_csv(csv_path)

housing = load_housing_data()housing.head()

housing.info()

housing["ocean_proximity"].value_counts()

housing.describe()

%matplotlib inlineimport matplotlib.pyplot as plthousing.hist(bins=50, figsize=(20,15))save_fig("attribute_histogram_plots")plt.show()

# 일관된 출력을 위해 유사난수 초기화np.random.seed(42)

테스트 데이터 셋 만들기

import numpy as np# 예시를 위해서 만든 것입니다. 사이킷런에는 train_test_split() 함수가 있습니다.def split_train_test(data, test_ratio):    shuffled_indices = np.random.permutation(len(data))    test_set_size = int(len(data) * test_ratio)    test_indices = shuffled_indices[:test_set_size]    train_indices = shuffled_indices[test_set_size:]    return data.iloc[train_indices], data.iloc[test_indices]

train_set, test_set = split_train_test(housing, 0.2)print(len(train_set), "train +", len(test_set), "test")

from zlib import crc32def test_set_check(identifier, test_ratio):    return crc32(np.int64(identifier)) & 0xffffffff < test_ratio * 2**32def split_train_test_by_id(data, test_ratio, id_column):    ids = data[id_column]    in_test_set = ids.apply(lambda id_: test_set_check(id_, test_ratio))    return data.loc[~in_test_set], data.loc[in_test_set]

import hashlibdef test_set_check(identifier, test_ratio, hash=hashlib.md5):    return bytearray(hash(np.int64(identifier)).digest())[-1] < 256 * test_ratio

# 이 버전의 test_set_check() 함수가 파이썬 2도 지원합니다.def test_set_check(identifier, test_ratio, hash=hashlib.md5):    return bytearray(hash(np.int64(identifier)).digest())[-1] < 256 * test_ratio

housing_with_id = housing.reset_index()   # `index` 열이 추가된 데이터프레임이 반환됩니다.train_set, test_set = split_train_test_by_id(housing_with_id, 0.2, "index")

housing_with_id["id"] = housing["longitude"] * 1000 + housing["latitude"]train_set, test_set = split_train_test_by_id(housing_with_id, 0.2, "id")

test_set.head()

housing["median_income"].hist()

# 소득 카테고리 개수를 제한하기 위해 1.5로 나눕니다.housing["income_cat"] = np.ceil(housing["median_income"] / 1.5)# 5 이상은 5로 레이블합니다.housing["income_cat"].where(housing["income_cat"] < 5, 5.0, inplace=True)

housing["income_cat"].value_counts()

housing["income_cat"].hist()save_fig('income_category_hist')

from sklearn.model_selection import StratifiedShuffleSplitsplit = StratifiedShuffleSplit(n_splits=1, test_size=0.2, random_state=42)for train_index, test_index in split.split(housing, housing["income_cat"]):    strat_train_set = housing.loc[train_index]    strat_test_set = housing.loc[test_index]

strat_test_set["income_cat"].value_counts() / len(strat_test_set)

housing["income_cat"].value_counts() / len(housing)

from sklearn.model_selection import train_test_splitdef income_cat_proportions(data):    return data["income_cat"].value_counts() / len(data)train_set, test_set = train_test_split(housing, test_size=0.2, random_state=42)compare_props = pd.DataFrame({    "Overall": income_cat_proportions(housing),    "Stratified": income_cat_proportions(strat_test_set),    "Random": income_cat_proportions(test_set),}).sort_index()compare_props["Rand. %error"] = 100 * compare_props["Random"] / compare_props["Overall"] - 100compare_props["Strat. %error"] = 100 * compare_props["Stratified"] / compare_props["Overall"] - 100

compare_props

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

데이터 이해를 위한 탐색과 시각화

housing = strat_train_set.copy()

ax = housing.plot(kind="scatter", x="longitude", y="latitude")ax.set(xlabel='경도', ylabel='위도')save_fig("bad_visualization_plot")

# 밀집된 지역을 보다 잘 보여주는 산점도ax = housing.plot(kind="scatter", x="longitude", y="latitude", alpha=0.1)ax.set(xlabel='경도', ylabel='위도')save_fig("better_visualization_plot")

# 낮은 가격: 파란색 -> 높은 가격: 빨간색ax = housing.plot(kind="scatter", x="longitude", y="latitude", alpha=0.4,    s=housing["population"]/100, label="인구", figsize=(10,7),    c="median_house_value", cmap=plt.get_cmap("jet"), colorbar=True,    sharex=False)ax.set(xlabel='경도', ylabel='위도')plt.legend()save_fig("housing_prices_scatterplot")

상관관계 조사

corr_matrix = housing.corr()

corr_matrix["median_house_value"].sort_values(ascending=False)

from pandas.plotting import scatter_matrixattributes = ["median_house_value", "median_income", "total_rooms",              "housing_median_age"]scatter_matrix(housing[attributes], figsize=(12, 8))save_fig("scatter_matrix_plot")

housing.plot(kind="scatter", x="median_income", y="median_house_value",             alpha=0.1)plt.axis([0, 16, 0, 550000])save_fig("income_vs_house_value_scatterplot")

housing["rooms_per_household"] = housing["total_rooms"]/housing["households"]housing["bedrooms_per_room"] = housing["total_bedrooms"]/housing["total_rooms"]housing["population_per_household"]=housing["population"]/housing["households"]

corr_matrix = housing.corr()corr_matrix["median_house_value"].sort_values(ascending=False)

housing.plot(kind="scatter", x="rooms_per_household", y="median_house_value",             alpha=0.2)plt.axis([0, 5, 0, 520000])plt.show()

housing.describe()

머신러닝 알고리즘을 위한 데이터 준비

데이터 정제

housing = strat_train_set.drop("median_house_value", axis=1) # 훈련 세트를 위해 레이블 삭제housing_labels = strat_train_set["median_house_value"].copy()

sample_incomplete_rows = housing[housing.isnull().any(axis=1)].head()sample_incomplete_rows

sample_incomplete_rows.dropna(subset=["total_bedrooms"])    # 옵션 1

sample_incomplete_rows.drop("total_bedrooms", axis=1)       # 옵션 2

median = housing["total_bedrooms"].median()sample_incomplete_rows["total_bedrooms"].fillna(median, inplace=True) # 옵션 3sample_incomplete_rows

#from sklearn.preprocessing import Imputerfrom sklearn.impute import SimpleImputerimputer = SimpleImputer(strategy="median")

housing_num = housing.drop('ocean_proximity', axis=1)# 다른 방법: housing_num = housing.select_dtypes(include=[np.number])

imputer.fit(housing_num)

imputer.statistics_

housing_num.median().values

X = imputer.transform(housing_num)

housing_tr = pd.DataFrame(X, columns=housing_num.columns,                          index = list(housing.index.values))

housing_tr.loc[sample_incomplete_rows.index.values]

imputer.strategy

housing_tr = pd.DataFrame(X, columns=housing_num.columns)housing_tr.head()

텍스트와 범주형 특성 다루기

housing_cat = housing['ocean_proximity']housing_cat.head(10)

housing_cat_encoded, housing_categories = housing_cat.factorize()housing_cat_encoded[:10]

housing_categories

from sklearn.preprocessing import OneHotEncoderencoder = OneHotEncoder(categories='auto')housing_cat_1hot = encoder.fit_transform(housing_cat_encoded.reshape(-1,1))housing_cat_1hot

housing_cat_1hot.toarray()

# [PR #9151](https://github.com/scikit-learn/scikit-learn/pull/9151)에서 가져온 CategoricalEncoder 클래스의 정의.# 이 클래스는 사이킷런 0.20에 포함될 예정입니다.from sklearn.base import BaseEstimator, TransformerMixinfrom sklearn.utils import check_arrayfrom sklearn.preprocessing import LabelEncoderfrom scipy import sparseclass CategoricalEncoder(BaseEstimator, TransformerMixin):    """Encode categorical features as a numeric array.    The input to this transformer should be a matrix of integers or strings,    denoting the values taken on by categorical (discrete) features.    The features can be encoded using a one-hot aka one-of-K scheme    (``encoding='onehot'``, the default) or converted to ordinal integers    (``encoding='ordinal'``).    This encoding is needed for feeding categorical data to many scikit-learn    estimators, notably linear models and SVMs with the standard kernels.    Read more in the :ref:`User Guide `.    Parameters    ----------    encoding : str, 'onehot', 'onehot-dense' or 'ordinal'        The type of encoding to use (default is 'onehot'):        - 'onehot': encode the features using a one-hot aka one-of-K scheme          (or also called 'dummy' encoding). This creates a binary column for          each category and returns a sparse matrix.        - 'onehot-dense': the same as 'onehot' but returns a dense array          instead of a sparse matrix.        - 'ordinal': encode the features as ordinal integers. This results in          a single column of integers (0 to n_categories - 1) per feature.    categories : 'auto' or a list of lists/arrays of values.        Categories (unique values) per feature:        - 'auto' : Determine categories automatically from the training data.        - list : ``categories[i]`` holds the categories expected in the ith          column. The passed categories are sorted before encoding the data          (used categories can be found in the ``categories_`` attribute).    dtype : number type, default np.float64        Desired dtype of output.    handle_unknown : 'error' (default) or 'ignore'        Whether to raise an error or ignore if a unknown categorical feature is        present during transform (default is to raise). When this is parameter        is set to 'ignore' and an unknown category is encountered during        transform, the resulting one-hot encoded columns for this feature        will be all zeros.        Ignoring unknown categories is not supported for        ``encoding='ordinal'``.    Attributes    ----------    categories_ : list of arrays        The categories of each feature determined during fitting. When        categories were specified manually, this holds the sorted categories        (in order corresponding with output of `transform`).    Examples    --------    Given a dataset with three features and two samples, we let the encoder    find the maximum value per feature and transform the data to a binary    one-hot encoding.    >>> from sklearn.preprocessing import CategoricalEncoder    >>> enc = CategoricalEncoder(handle_unknown='ignore')    >>> enc.fit([[0, 0, 3], [1, 1, 0], [0, 2, 1], [1, 0, 2]])    ... # doctest: +ELLIPSIS    CategoricalEncoder(categories='auto', dtype=<... 'numpy.float64'>,              encoding='onehot', handle_unknown='ignore')    >>> enc.transform([[0, 1, 1], [1, 0, 4]]).toarray()    array([[ 1.,  0.,  0.,  1.,  0.,  0.,  1.,  0.,  0.],           [ 0.,  1.,  1.,  0.,  0.,  0.,  0.,  0.,  0.]])    See also    --------    sklearn.preprocessing.OneHotEncoder : performs a one-hot encoding of      integer ordinal features. The ``OneHotEncoder assumes`` that input      features take on values in the range ``[0, max(feature)]`` instead of      using the unique values.    sklearn.feature_extraction.DictVectorizer : performs a one-hot encoding of      dictionary items (also handles string-valued features).    sklearn.feature_extraction.FeatureHasher : performs an approximate one-hot      encoding of dictionary items or strings.    """    def __init__(self, encoding='onehot', categories='auto', dtype=np.float64,                 handle_unknown='error'):        self.encoding = encoding        self.categories = categories        self.dtype = dtype        self.handle_unknown = handle_unknown    def fit(self, X, y=None):        """Fit the CategoricalEncoder to X.        Parameters        ----------        X : array-like, shape [n_samples, n_feature]            The data to determine the categories of each feature.        Returns        -------        self        """        if self.encoding not in ['onehot', 'onehot-dense', 'ordinal']:            template = ("encoding should be either 'onehot', 'onehot-dense' "                        "or 'ordinal', got %s")            raise ValueError(template % self.handle_unknown)        if self.handle_unknown not in ['error', 'ignore']:            template = ("handle_unknown should be either 'error' or "                        "'ignore', got %s")            raise ValueError(template % self.handle_unknown)        if self.encoding == 'ordinal' and self.handle_unknown == 'ignore':            raise ValueError("handle_unknown='ignore' is not supported for"                             " encoding='ordinal'")        X = check_array(X, dtype=np.object, accept_sparse='csc', copy=True)        n_samples, n_features = X.shape        self._label_encoders_ = [LabelEncoder() for _ in range(n_features)]        for i in range(n_features):            le = self._label_encoders_[i]            Xi = X[:, i]            if self.categories == 'auto':                le.fit(Xi)            else:                valid_mask = np.in1d(Xi, self.categories[i])                if not np.all(valid_mask):                    if self.handle_unknown == 'error':                        diff = np.unique(Xi[~valid_mask])                        msg = ("Found unknown categories {0} in column {1}"                               " during fit".format(diff, i))                        raise ValueError(msg)                le.classes_ = np.array(np.sort(self.categories[i]))        self.categories_ = [le.classes_ for le in self._label_encoders_]        return self    def transform(self, X):        """Transform X using one-hot encoding.        Parameters        ----------        X : array-like, shape [n_samples, n_features]            The data to encode.        Returns        -------        X_out : sparse matrix or a 2-d array            Transformed input.        """        X = check_array(X, accept_sparse='csc', dtype=np.object, copy=True)        n_samples, n_features = X.shape        X_int = np.zeros_like(X, dtype=np.int)        X_mask = np.ones_like(X, dtype=np.bool)        for i in range(n_features):            valid_mask = np.in1d(X[:, i], self.categories_[i])            if not np.all(valid_mask):                if self.handle_unknown == 'error':                    diff = np.unique(X[~valid_mask, i])                    msg = ("Found unknown categories {0} in column {1}"                           " during transform".format(diff, i))                    raise ValueError(msg)                else:                    # Set the problematic rows to an acceptable value and                    # continue `The rows are marked `X_mask` and will be                    # removed later.                    X_mask[:, i] = valid_mask                    X[:, i][~valid_mask] = self.categories_[i][0]            X_int[:, i] = self._label_encoders_[i].transform(X[:, i])        if self.encoding == 'ordinal':            return X_int.astype(self.dtype, copy=False)        mask = X_mask.ravel()        n_values = [cats.shape[0] for cats in self.categories_]        n_values = np.array([0] + n_values)        indices = np.cumsum(n_values)        column_indices = (X_int + indices[:-1]).ravel()[mask]        row_indices = np.repeat(np.arange(n_samples, dtype=np.int32),                                n_features)[mask]        data = np.ones(n_samples * n_features)[mask]        out = sparse.csc_matrix((data, (row_indices, column_indices)),                                shape=(n_samples, indices[-1]),                                dtype=self.dtype).tocsr()        if self.encoding == 'onehot-dense':            return out.toarray()        else:            return out

#from sklearn.preprocessing import CategoricalEncoder # Scikit-Learn 0.20에서 추가 예정cat_encoder = CategoricalEncoder()housing_cat_reshaped = housing_cat.values.reshape(-1, 1)housing_cat_1hot = cat_encoder.fit_transform(housing_cat_reshaped)housing_cat_1hot

from sklearn.preprocessing import OneHotEncodercat_encoder = OneHotEncoder(categories='auto')housing_cat_reshaped = housing_cat.values.reshape(-1, 1)housing_cat_1hot = cat_encoder.fit_transform(housing_cat_reshaped)housing_cat_1hot

housing_cat_1hot.toarray()

# cat_encoder = CategoricalEncoder(encoding="onehot-dense")cat_encoder = OneHotEncoder(categories='auto', sparse=False)housing_cat_1hot = cat_encoder.fit_transform(housing_cat_reshaped)housing_cat_1hot

cat_encoder.categories_

나만의 변환기

from sklearn.base import BaseEstimator, TransformerMixin# 컬럼 인덱스rooms_ix, bedrooms_ix, population_ix, household_ix = 3, 4, 5, 6class CombinedAttributesAdder(BaseEstimator, TransformerMixin):    def __init__(self, add_bedrooms_per_room = True): # no *args or **kargs        self.add_bedrooms_per_room = add_bedrooms_per_room    def fit(self, X, y=None):        return self  # nothing else to do    def transform(self, X, y=None):        rooms_per_household = X[:, rooms_ix] / X[:, household_ix]        population_per_household = X[:, population_ix] / X[:, household_ix]        if self.add_bedrooms_per_room:            bedrooms_per_room = X[:, bedrooms_ix] / X[:, rooms_ix]            return np.c_[X, rooms_per_household, population_per_household,                         bedrooms_per_room]        else:            return np.c_[X, rooms_per_household, population_per_household]attr_adder = CombinedAttributesAdder(add_bedrooms_per_room=False)housing_extra_attribs = attr_adder.transform(housing.values)

housing_extra_attribs = pd.DataFrame(    housing_extra_attribs,    columns=list(housing.columns)+["rooms_per_household", "population_per_household"])housing_extra_attribs.head()

변환 파이프라인

from sklearn.pipeline import Pipelinefrom sklearn.preprocessing import StandardScalernum_pipeline = Pipeline([        ('imputer', SimpleImputer(strategy="median")),        ('attribs_adder', CombinedAttributesAdder()),        ('std_scaler', StandardScaler()),    ])housing_num_tr = num_pipeline.fit_transform(housing_num)

housing_num_tr

# from future_encoders import ColumnTransformerfrom sklearn.compose import ColumnTransformernum_attribs = list(housing_num)cat_attribs = ["ocean_proximity"]full_pipeline = ColumnTransformer([        ("num", num_pipeline, num_attribs),        ("cat", OneHotEncoder(categories='auto'), cat_attribs),    ])housing_prepared = full_pipeline.fit_transform(housing)housing_prepared

from sklearn.base import BaseEstimator, TransformerMixin# 사이킷런이 DataFrame을 바로 사용하지 못하므로# 수치형이나 범주형 컬럼을 선택하는 클래스를 만듭니다.class DataFrameSelector(BaseEstimator, TransformerMixin):    def __init__(self, attribute_names):        self.attribute_names = attribute_names    def fit(self, X, y=None):        return self    def transform(self, X):        return X[self.attribute_names].values

num_attribs = list(housing_num)cat_attribs = ["ocean_proximity"]num_pipeline = Pipeline([        ('selector', DataFrameSelector(num_attribs)),        ('imputer', SimpleImputer(strategy="median")),        ('attribs_adder', CombinedAttributesAdder()),        ('std_scaler', StandardScaler()),    ])cat_pipeline = Pipeline([        ('selector', DataFrameSelector(cat_attribs)),        ('cat_encoder', CategoricalEncoder(encoding="onehot-dense")),    ])

cat_pipeline = Pipeline([        ('selector', DataFrameSelector(cat_attribs)),        ('cat_encoder', OneHotEncoder(categories='auto', sparse=False)),    ])

# full_pipeline = FeatureUnion(transformer_list=[#         ("num_pipeline", num_pipeline),#         ("cat_pipeline", cat_pipeline),#     ])full_pipeline = ColumnTransformer([        ("num_pipeline", num_pipeline, num_attribs),        ("cat_encoder", OneHotEncoder(categories='auto'), cat_attribs),    ])

housing_prepared = full_pipeline.fit_transform(housing)housing_prepared

모델 선택과 훈련

훈련 세트에서 훈련하고 평가하기

from sklearn.linear_model import LinearRegressionlin_reg = LinearRegression()lin_reg.fit(housing_prepared, housing_labels)

# 훈련 샘플 몇 개를 사용해 전체 파이프라인을 적용해 보겠습니다.some_data = housing.iloc[:5]some_labels = housing_labels.iloc[:5]some_data_prepared = full_pipeline.transform(some_data)print("예측:", lin_reg.predict(some_data_prepared))

print("레이블:", list(some_labels))

some_data_prepared

from sklearn.metrics import mean_squared_errorhousing_predictions = lin_reg.predict(housing_prepared)lin_mse = mean_squared_error(housing_labels, housing_predictions)lin_rmse = np.sqrt(lin_mse)lin_rmse

from sklearn.metrics import mean_absolute_errorlin_mae = mean_absolute_error(housing_labels, housing_predictions)lin_mae

from sklearn.tree import DecisionTreeRegressortree_reg = DecisionTreeRegressor(random_state=42)tree_reg.fit(housing_prepared, housing_labels)

housing_predictions = tree_reg.predict(housing_prepared)tree_mse = mean_squared_error(housing_labels, housing_predictions)tree_rmse = np.sqrt(tree_mse)tree_rmse

교차 검증을 사용한 평가

from sklearn.model_selection import cross_val_scorescores = cross_val_score(tree_reg, housing_prepared, housing_labels,                         scoring="neg_mean_squared_error", cv=10)tree_rmse_scores = np.sqrt(-scores)

def display_scores(scores):    print("점수:", scores)    print("평균:", scores.mean())    print("표준편차:", scores.std())display_scores(tree_rmse_scores)

lin_scores = cross_val_score(lin_reg, housing_prepared, housing_labels,                             scoring="neg_mean_squared_error", cv=10)lin_rmse_scores = np.sqrt(-lin_scores)display_scores(lin_rmse_scores)

from sklearn.ensemble import RandomForestRegressorforest_reg = RandomForestRegressor(n_estimators=10, random_state=42)forest_reg.fit(housing_prepared, housing_labels)

housing_predictions = forest_reg.predict(housing_prepared)forest_mse = mean_squared_error(housing_labels, housing_predictions)forest_rmse = np.sqrt(forest_mse)forest_rmse

from sklearn.model_selection import cross_val_scoreforest_scores = cross_val_score(forest_reg, housing_prepared, housing_labels,                                scoring="neg_mean_squared_error", cv=10)forest_rmse_scores = np.sqrt(-forest_scores)display_scores(forest_rmse_scores)

scores = cross_val_score(lin_reg, housing_prepared, housing_labels, scoring="neg_mean_squared_error", cv=10)pd.Series(np.sqrt(-scores)).describe()

모델 세부 튜닝

그리드 탐색

from sklearn.model_selection import GridSearchCVparam_grid = [    # 하이퍼파라미터 12(=3×4)개의 조합을 시도합니다.    {'n_estimators': [3, 10, 30], 'max_features': [2, 4, 6, 8]},    # bootstrap은 False로 하고 6(=2×3)개의 조합을 시도합니다.    {'bootstrap': [False], 'n_estimators': [3, 10], 'max_features': [2, 3, 4]},  ]forest_reg = RandomForestRegressor(random_state=42)# 다섯 폴드에서 훈련하면 총 (12+6)*5=90번의 훈련이 일어납니다.grid_search = GridSearchCV(forest_reg, param_grid, cv=5, scoring='neg_mean_squared_error',                           return_train_score=True, n_jobs=-1)grid_search.fit(housing_prepared, housing_labels)

grid_search.best_params_

grid_search.best_estimator_

cvres = grid_search.cv_results_for mean_score, params in zip(cvres["mean_test_score"], cvres["params"]):    print(np.sqrt(-mean_score), params)

pd.DataFrame(grid_search.cv_results_)

랜덤 탐색

from sklearn.model_selection import RandomizedSearchCVfrom scipy.stats import randintparam_distribs = {        'n_estimators': randint(low=1, high=200),        'max_features': randint(low=1, high=8),    }forest_reg = RandomForestRegressor(random_state=42)rnd_search = RandomizedSearchCV(forest_reg, param_distributions=param_distribs,                                n_iter=10, cv=5, scoring='neg_mean_squared_error',                                random_state=42, n_jobs=-1)rnd_search.fit(housing_prepared, housing_labels)

cvres = rnd_search.cv_results_for mean_score, params in zip(cvres["mean_test_score"], cvres["params"]):    print(np.sqrt(-mean_score), params)

앙상블 방법

최상의 모델과 오차 분석

feature_importances = grid_search.best_estimator_.feature_importances_feature_importances

extra_attribs = ["rooms_per_hhold", "pop_per_hhold", "bedrooms_per_room"]# cat_encoder = cat_pipeline.named_steps["cat_encoder"]cat_encoder = full_pipeline.named_transformers_["cat_encoder"]cat_one_hot_attribs = list(cat_encoder.categories_[0])attributes = num_attribs + extra_attribs + cat_one_hot_attribssorted(zip(feature_importances, attributes), reverse=True)

테스트 세트로 시스템 평가하기

final_model = grid_search.best_estimator_X_test = strat_test_set.drop("median_house_value", axis=1)y_test = strat_test_set["median_house_value"].copy()X_test_prepared = full_pipeline.transform(X_test)final_predictions = final_model.predict(X_test_prepared)final_mse = mean_squared_error(y_test, final_predictions)final_rmse = np.sqrt(final_mse)

final_rmse
47873.26095812988