머신러닝 프로젝트 실행 -3

머신러닝 프로젝트 실행 1~3단계에 이어, 4단계를 정리하도록 하겠습니다.

4. 기본 데이터 패턴을 머신러닝 알고리즘에 더 잘 노출할 수 있도록 데이터 준비하기

머신러닝 알고리즘을 위한 데이터를 준비할 시간입니다. 이것을 수동으로 하는 대신에, 자동으로 생성할 함수들을 사용해야 합니다. 

그 이유는 다음과 같습니다.

• 어떤 데이터셋이든(예, 다음 번에 새로운 데이터셋을 얻게 되었을 때), 이들 변환을 쉽게 재적용할 수 있도록 해줍니다.
• 미래의 프로젝트에서 재사용할 수 있는 변환 함수 라이브러리를 만들 수 있습니다.
• 이들 함수들을 알고리즘에 피딩하기 전에 새로운 데이터를 변환하기 위해 실제 사용하는 시스템에서 사용할 수 있습니다. 
• 다양한 변환을 쉽게 시도하고 어떤 변환 조합이 가장 잘 동작하는지 알 수 있도록 해줍니다.

이제 트레이닝 셋을 클리닝하기 위해 되돌려 봅시다(다시 한번strat_train_set을 복사하면 됩니다). 그리고 불필요하게 예측변수와 목표 값들에 동일한 변환이 적용되기를 원하지 않기 때문에 예측변수와 레이블을 분리하도록 합시다.

(drop()이 데이터 복사본을 만들고, strat_train_set에는 영향을 주지 않는 것에 주의하시기 바랍니다) 

>>> housing = strat_train_set.drop("median_house_value", axis=1)

>>> housing_labels = strat_train_set["median_house_value"].copy()

데이터 클리닝

대부분의 머신러닝 알고리즘은 누락된 값이 있는 피처들(features)로는 작업할 수 없습니다. 따라서, 그것들을 다루기 위한 몇가지 함수들을 만들어 봅시다. 전 단계에서 total_bedrooms 속성에 누락된 값들이 있다는 것을 보았습니다. 이것을 고쳐보도록 합시다. 

다음의 3가지 옵션을 선택할 수 있습니다.

• 상응하는 지구(districts)를 제거합니다.

• 전체 속성을 제거합니다.

• 값들을 특정 값으로 설정합니다(제로, 평균, 중앙값 등).

이것들을 DataFrame의 dropna(), drop(), 그리고 fillna() 메서드를 사용해 쉽게 처리할 수 있습니다.

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

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

>>> median = housing["total_bedrooms"].median()

>>> housing["total_bedrooms"].fillna(median) # 옵션3

만약 옵션3을 선택한다면, 트레이닝 셋에 대한 중앙값을 계산해야만 합니다. 그리고 트레이닝 셋의 누락된 값들에 이것을 적용해야 합니다. 

하지만, 위 코드처럼 계산했던 중앙값을 저장하는 것을 잊지 말아야 합니다. 

나중에 시스템을 평가하고 싶을 때, 테스트 셋에서 누락된 값들을 대체하는 것이 필요할 것입니다. 그리고, 시스템을 운영한 후에는 신규 데이터에서 누락된 값들을 즉석에서 대체해야 합니다.

>>> from sklearn.preprocessing import Imputer

>>> imputer = Imputer(strategy="median")

중앙값은 수치 속성들에 대해서만 계산될 수 있기 때문에, 텍스트 속성의 ocean_proximity를 제외한 데이터의 복사본을 생성하는 것이 필요합니다.

>>> housing_num = housing.drop("ocean_proximity", axis=1)

이제 fit() 메서드를 사용해 트레이닝 데이터에 imputer 인스턴스를 적용할 수 있습니다.

>>> imputer.fit(housing_num)

imputer는 간단하게 각 속성의 중앙값을 계산하고, 그 결과를 statistics_ 인스턴스 변수에 저장합니다. 

total_bedrooms 속성만이 누락된 값이 있지만, 이 시스템이 실제 운용되었을 때 신규 데이터에 어떤 누락된 값들이 있을지 확신할 수 없을 것입니다. 

그래서, 모든 수치 속성들에 대해 imputer를 적용하는 것이 더 안전합니다.

>>> imputer.statistics_

array([ -118.51 , 34.26 , 29. , 2119. , 433. , 1164. , 408. , 3.5414])

>>> housing_nim.median().values

array([ -118.51 , 34.26 , 29. , 2119. , 433. , 1164. , 408. , 3.5414]) 

이제 학습된 중앙값으로 누락된 값들을 대체함으로써 트레이닝 셋을 변환하기 위해 "훈련된" imputer를 이용할 수 있습니다. 

>>> X = imputer.transform(housing_num)

결과물은 변환된 피쳐들(features)을 포함한 평이한 넘파이(Numpy) 배열입니다. 

판다스(Pandas) DataFrame으로 다시 넣고 싶다면, 간단히 처리할 수 있습니다.

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

텍스트 다루기와 범주 속성들

앞에서 범주 속성인 ocean_proximity를 제외했습니다. 

그 이유는 텍스트 속성이기 때문에 중앙값을 계산할 수 없기 때문입니다. 

대부분의 머신러닝 알고리즘은 숫자를 가지고 작업하는 것을 선호합니다. 

그렇기 때문에 이들 텍스트 라벨을 숫자로 변환해 봅시다.

사이킷 런(Scikit-Learn)은 이 작업에 필요한 LabelEncoder라 불리는 변환기를 제공합니다.

>>> from sklearn.preprocessing import LabelEncoder

>>> encoder = LabelEncoder()

>>> housing_cat = housing["ocean_proximity"]

>>> housing_cat_encoded = encoder.fit_transform(housing_cat)

>>> housing_cat_encoded

array([1, 1, 4, ..., 1, 0, 3])

이러면 더 좋아집니다: 이제 어떤 ML 알고리즘에서도 이 숫자 데이터를 사용할 수 있습니다. 

이 인코더가 classes_ 속성을 사용하여 학습한 매핑을 볼 수 있습니다("<1H OCEAN"이 0에 매핑되었고, "INLAND"가 1에 매핑되었습니다).

>>> print(encoder.classes_)

['<1H OCEAN' 'INLAND' 'ISLAND' 'NEAR BAY' 'NEAR OCEAN']

위 인코더로 처리한 데이터의 한가지 이슈는 ML 알고리즘이 두개의 근접한 값들이 거리가 있는 두개의 값들보다 더 유사하다고 가정한다는 것입니다. 

분명히 이것은 그런 경우가 아닌데 말입니다(예를 들어, 범주 0과 4가 범주 0과 1보다 더 유사합니다). 

이 이슈를 수정하기 위한, 일반적인 솔루션은 각 범주에 대한 하나의 바이너리 속성을 생성하는 것입니다: 범주가 "<1H OCEAN"일 때 하나의 속성은 1과 같습니다(그렇지 않으면 0). 범주가 "INLAND"일 때 또 다른 속성이 1과 같습니다(그렇지 않으면 0) 등등. 

이것을 원-핫 인코딩이라 부릅니다. 범주들을 원-핫 벡터들로 인코딩합시다. 

fit_transform()은 2D 배열을 기대하지만, housing_cat_encoded는 1D 배열이라는 것을 주의하시기 바랍니다. 

그래서 이것을 재구성하는 것이 필요합니다.

>>> from sklearn.preprocessing import OneHotEncoder

>>> encoder = OneHotEncoder()

>>> housing_cat_1hot = encoder.fit_transform(housing_cat_encoded.reshape(-1,1))

>>> housing_cat_1hot

<16513x5 sparse matrix of type '<class 'numpy.float64'>'

        with 16513 stored elements in Compressed Sparse Row format>

산출물이 NumPy 배열이 아니라 SciPy 스파스(sparse) 매트릭스인 것에 유의하시기 바랍니다. 

이것은 수천 개의 범주들을 가진 범주 속성을 가질 때 매우 유용합니다. 

원-핫 인코딩 후, 수천개의 컬럼을 가진 매트릭스를 얻었습니다. 

그리고 그 매트릭스는 각 열마다 하나의 1을 가진 것 말고는 0으로 가득합니다. 엄청난 메모리를 0을 저장하는데 사용하는 것은 매우 비효율적입니다. 

그래서 대신 스파스(sparse) 매트릭스는 오직 0이 아닌 요소들의 위치만 저장합니다. 대개 일반적인 2D 배열처럼 사용할 수 있습니다. 하지만 정말 NumPy 배열로 전환하고 싶다면, toarray() 메서드를 호출하기만 하면 됩니다. 

>>> housing_cat_1hot.toarray()

array([[ 0.,  1.,  0.,  0.,  0.],

    [0.,  1.,  0.,  0.,  0.],  

    [0.,  0.,  0.,  0.,  1.], 

    [1.,  0.,  0.,  0.,  0.],  

    [0.,  0.,  0.,  1.,  0.]])

  

LabelBinarizer 클래스를 사용해서 (텍스트 범주에서 숫자 범주로 바꾸고, 숫자 범주에서 원-핫 벡터로 바꾸는) 두개의 변환을 한번에 적용할 수 있습니다. 

>>> from sklearn.preprocessing import LabelBinarizer

>>> encoder = LabelBinarizer()

>>> housing_cat_1hot = encoder.fit_transform(housing_cat)

>>> housing_cat_1hot

array([[ 0,  1,  0,  0,  0],

    [0,  1,  0,  0,  0],  

    [0,  0,  0,  0,  1], 

 ...,

    [0,  0,  0,  0,  1], 

    [1,  0,  0,  0,  0],  

    [0,  0,  0,  1,  0]])

기본적으로 고밀도 NumPy 배열을 돌려준다는 것에 유의하시기 바랍니다. 

sparse_output=True를 LabelBinarizer 컨스트럭터(constructor)를 전달함으로써 스파스(sparse) 매트릭스를 얻을 수 있습니다. 

사용자 정의 트랜스포머(Transformers)

사이킷런(Scikit-Learn)이 많은 유용한 트랜스포머(Transformers)를 제공하지만, 사용자 정의 클린업 또는 특정 속성들을 결합하는 것과 같은 작업을 위해 자신만의 트랜스포머를 작성하는 것이 필요할 것입니다. 

사이킷런(Scikit-Learn)의 기능들(pipelines과 같은)을 가지고 완벽하게 작동하는 자신만의 트랜스포머를 원할 수 있습니다. 

사이킷런(Scikit-Learn)이 덕 타이핑(상속이 아닌)에 의존하기 때문에, 클래스를 생성하고 3개의 메서드 구현하는 것이 필요한 전부입니다: fit(), transform(), 그리고 fit_transform(). 간단히 기본 클래스로써 TransformerMixin을 추가함으로써 무료로 하나를 얻을 수 있습니다. 

또한, 기본 클래스로 BaseEstimater를 추가한다면(컨스트럭터(constructor)에 *args와 *kargs를 피하세요), 자동 하이퍼파라미터를 조율하는데 유용한 두개의 특별 메서드(get_params()와 set_params())를 얻을 수 있습니다. 

예를 들어, 아래 코드는 앞에서 논의한 결합된 속성들을 추가하는 작은 트랜스포머(transformer) 클래스입니다. 

* 컴퓨터 프로그래밍 분야에서 덕 타이핑(duck typing)은 동적 타이핑의 한 종류로, 객체의 변수 및 메소드의 집합이 객체의 타입을 결정하는 것을 말합니다. 

>>> from sklearn.base import BaseEstimator, TransformerMixin

>>> rooms_ix, bedrooms_ix, population_ix, household_ix = 3,4,5,6

>>> class CombineAttributesAdder(BaseEstimator, TransformerMixin):

def __init__(self, add_bedrooms_per_room = True): # *args와 *kargs를 피하세요

self.add_bedrooms_per_room = add_bedrooms_per_room

def fit(self, X, y=None):

return self # 할 일은 없습니다

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 = CombineAttributesAdder(add_bedrooms_per_room=False)

>>> housing_extra_attribs = attr_adder.transform(housing.values)

이 예에서, 트랜스포머(transformer)는 기본적으로 True를 설정한(흔히 민감한 기본값을 제공하는데 도움이 됨), 하나의 하이퍼파라미터, add_bedrooms_per_room를 가지고 있습니다. 

이 하이퍼 파라미터는 이 속성을 추가하는 것이 머신러닝 알고리즘에 도움이 되는지 안되는지 쉽게 찾을 수 있도록 해줄 것입니다. 

더 일반적으로, 100% 확신할 수 없는 어떤 데이터를 준비하는 단계에서 점검하기 위한 하이퍼파라미터를 추가할 수 있습니다. 

이들 데이터의 준비 단계를 더 많이 자동화하고, 자동화를 시도할 수 있는 결합을 더 많이 할수록, 매우 좋은 결합을 발견할 가능성이 매우 높아질 것입니다(그리고 많은 시간을 절약하게 해 줄 것입니다).

피처(Feature) 스케일링(Scaling)

데이터에 적용이 필요한 가장 중요한 변환 중 하나는 피처(feature) 스케일링(scaling)입니다. 

몇 가지 예외가 있지만, 머신러닝 알고리즘은 입력 숫치 속성들이 매우 다른 스케일링을 가지면 잘 수행되지 않습니다. 

housing 데이터가 그런 경우입니다: 중간 소득이 0에서 15까지의 범위를 가지는 것에 비해, 전체 방수는 6에서 39,320까지의 범위를 가집니다. 목표 값의 스케일링은 일반적으로 필요하지 않다는 것에 유의하시기 바랍니다.

모든 속성들이 동일한 스케일을 갖도록 하는 두가지 일반적인 방법이 있습니다: min-max scaling과 standardization.

Min-max scaling(많은 사람들이 normalization이라 부릅니다)은 매우 간단합니다: 값들이 이동되어, 결국 0에서 1사의 범위에서 재스케일링 됩니다. 최소값을 뺀 값에, 최대값에서 최소값을 마이너스한 값을 나눔으로써 구합니다. 

사이킷런(Scikit-Learn)에서는 이를 위해 MinMaxScaler라는 트랜스포머를 제공합니다. 

어떤 이유로 0-1의 범위를 원하지 않을 때 범위를 변경할 수 있도록 feature_range라는 하이퍼트랜스포머를 갖습니다.

표준화(Standardization)는 전혀 다릅니다: 먼저 평균값을 구합니다(그래서 표준화된 값은 항상 제로 평균값을 갖습니다). 그런 다음 분산으로 나누어, 그 결과 분포가 단위 분산을 갖도록 합니다. 

min-max scaling과 달리, 표준화(Standardization)는 값을 특정 범위로 한정하지 않습니다. 

이것이 몇몇 알고리즘에서는 문제가 될 수도 있습니다(예를 들어, 뉴럴 네트워크는 흔히 입력 값의 범위를 0에서 1이라고 기대합니다). 하지만, 표준화(Standardization)는 특이값(outliers)에 의한 영향을 훨씬 덜 받습니다. 

예를 들어, 한 지구(district)의 중간 소득이 100과 같다고(실수로) 가정합시다. Min-max scaling은 모든 다른 값들이 0-15에서 0-0.15로 망가트립니다. 반면에 표준화(Standardization)는 별로 영향을 받지 않습니다. 

사이킷런(Scikit-Learn)은 표준화(Standardization)를 위해 StandardScaler라는 트랜스포머를 제공합니다.

변환 파이프라인(Pipeline)

보시다시피, 올바른 순서로 실행해야 하는 데이터 변환의 많은 단계가 있습니다. 

사이킷런(Scikit-Learn)은 그러한 일련의 변환을 도와줄 수 있는 파이프라인(Pipeline) 클래스를 제공합니다.

수치 속성들에 대한 작은 파이프라인 코드를 보시기 바랍니다:

>>> from sklearn.pipeline import Pipeline

>>> from sklearn.preprocessing import StandardScaler

>>> num_pipeline = Pipeline([

('imputer', Imputer(strategy="median")),

('attribs_adder', CombinedAttributesAdder()),

('std_scaler', StandardScaler()),

])

>>> housing_num_tr = num_pipeline.fit_transform(housing_num)

파이프라인(Pipeline) 생성자(constructor)는 일련의 단계를 정의하는 이름(name)/추정량(estimator) 쌍 리스트를 가집니다. 

마지막 추정량을 제외한 모든 것이 트랜스포머여야 합니다(예, 그것들은 fit_transform() 메서드를 가져야만 합니다). 

이름들(names)은 좋아하는 어떤 것으로도 정할 수 있습니다.

파이프라인의 fit() 메서드를 호출할 때, 마지막 추정량에 도달할 때까지, 파라미터로써 각 호출의 결과물을 다음 호출에 전달합니다. 

모든 트랜스포머에 대해 순차적으로 fit_transform()을 호출하며, 이를 위해서 fit() 메서드를 호출하기만 하면 됩니다.

파이프라인은 마지막 추정량으로써 동일한 메서드를 제공합니다. 마지막 추정량은 StandardScaler입니다. 

이것은 트랜스포머이기 때문에 파이프라인은 순차적으로 데이터에 모든 변환을 전달하는 transform() 메서드를 가집니다(또한 fit()과 함께 transform()을 호출하는 대신에 사용했던 fit_transform 메서드를 가집니다).

이제 수치 값들에 대한 파이프라인을 가지고 되었습니다. 그리고, LabelBinarizer를 범주 값들에 대해 적용하는 것이 필요합니다: 이러한 변환을 어떻게 단일 파이프라인에 결합시킬 수 있을까요? 사이킷런(Scikit-Learn)은 이것을 위해 FeatureUnion 클래스를 제공합니다. 변환 리스트를 제공하고(전체 변환 파이프라인이 될 수 있습니다), transform() 메서드가 호출되었을 때 각각의 변환에 대한 transform() 메서드가 병행으로 실행됩니다. 

결과물을 기다린 후, 그것들을 결합하고 결과값으로 돌려줍니다. 

수치와 범주 속성 양쪽을 핸들링하는 전체 파이프라인은 다음처럼 보여질 수 있습니다:

>>> from sklearn.pipeline import FeatureUnion

>>> num_attribs = list(housing_num)

>>> cat_attribs = ["ocean_proximity"]

>>> num_pipeline = Pipeline([

('selector', DataFrameSelector(num_attribs)),

('imputer', Imputer(strategy="median")),

('attribs_adder', CombinedAttributesAdder()),

('std_scaler', StandardScaler()),

])

>>> cat_pipeline = Pipeline([

('selector', DataFrameSelector(cat_attribs)),

('label_binarizer', LabelBinarizer()),

])

>>> full_pipeline = FeatureUnion(transformer_list=[

("num_pipeline", num_pipeline),

("cat_pipeline", cat_pipeline),

])

그리고 전체 파이프라인을 간단하기 실행할 수 있습니다:

>>> housing_prepared = full_pipeline.fit_transform(housing)

>>> housing_prepared

array([[ 0.73225807,  -0.67331551,  0.58426443,  ...,  0.           ,  0.          ,  0.           ],

 [-0.99102923,   1.63234656, -0.92655887,  ...,  0.           ,  0.          ,  0.           ],

 [...]

>>> housing_prepared.shape

(16513, 17)

각 서브 파이프라인은 선택기(selector) 파이프라인으로 시작합니다: 간단히 원하는 속성(수치 또는 범주)을 선택함으로써 데이터를 변환합니다. 

나머지를 버리고, 결과 DataFrame을 넘파이(NumPy) 배열로 전환합니다. 

사이킷런(Scikit-Learn)에서는 판다스(Pandas) DataFrame을 핸들링할 수 없기 때문에, 이 작업을 위해 간단한 사용자 정의 트랜스포머를 작성하는 것이 필요합니다.

>>> from sklearn.base import BaseEstimator, TransformerMixin

>>> 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

4단계는 여기까지입니다. 갈수록 어려워지는 것 같습니다. 다시 앞 단계 내용을 복습하면서 머리속에 정리해 넣어야겠습니다. ㅜㅜ

  

머신러닝 프로젝트 실행-1

(1~2단계: 1. 문제정의하고 전체 그림 바라보기/ 2. 데이터 얻기) 바로가기 

머신러닝 프로젝트 실행-2

(3단계: 인사이트를 찾기 위해 데이터 탐색하기) 바로가기 

참고)'Hands-On Machine Learning with Scikit-Learn and TensorFlow, chapter 2' 

주피터 노트북에서 볼 수 있는 전체 코드 얻기