Scikit-learn 라이브러리는 파이썬에서 가장 유명한 머신러닝 라이브러리 중 하나로, 분류(classification), 회귀(regression), 군집화(clustering), 의사결정 트리(decision tree) 등의 다양한 머신러닝 알고리즘을 적용할 수 있는 함수들을 제공합니다.

이번에는 머신러닝 수행 방법을 알아보기 전에, 다양한 샘플 데이터를 확보할 수 있는 방법들을 알아보려고 합니다.  

데이터셋(Datasets) 얻기

머신러닝을 시작할 때, 간단하게 데이터셋을 얻어서 알고리즘을 테스트해 보는 것이 머신러닝을 이해하는데 있어 매우 유용합니다. 간단한 데이터셋으로 원리를 이해한 후, 실제 생활에서 얻을 수 있는 더 큰 데이터셋을 가지고 작업하는 것이 좋습니다.

우선 머신러닝을 연습하기 위해, 간단한 데이터셋을 얻을 수 있는 곳은 다음과 같습니다. 하나씩 차례대로 알아보도록 하겠습니다.

• 사이킷런의 빌트인 데이터셋
• 캐글(Kaggle) 데이터셋
• UCI(캘리포니아 대학, 얼바인) 머신러닝 저장소

<사이킷런 데이터셋 사용하기>

사이킷런에는 머신러닝을 쉽게 배울 수 있도록 하기 위해, 샘플 데이터셋을 가지고 있습니다. 

샘플 데이터셋을 로드하기 위해, 데이터셋 모듈을 읽어들입니다. 다음은 Iris 데이터셋을 로드한 코드입니다.

>>> from sklearn import datasets

>>> iris = datasets.load_iris() # 아이리스 꽃 데이터셋 또는 피셔 아이리스 데이터셋은 영국의 통계 학자이자 생물학자인 로널드 피셔 (Ronald Fisher)가 소개한 다변수 데이터셋입니다. 데이터셋은 3종의 아이리스(Iris)로 된 50개 샘플로 구성되어 있습니다. 각 샘플로부터 4개의 피쳐(features:피쳐를 우리말로 변수 또는 요인이라고 표현하기도 함)를 측정할 수 있습니다: 꽃받침과 꽃잎의 길이와 너비입니다. 이러한 4가지 피쳐(features)의 결합을 바탕으로 피셔는 종을 서로 구분할 수 있는 선형 판별 모델을 개발했습니다. 

로드된 데이터셋은 속성-스타일 접근을 제공하는 파이썬 딕셔너리, 번치(bunch) 객체로 표현됩니다. 

>>> print(iris.DESCR) # DESCR 속성을 사용해 데이터셋의 정보를 다음과 같이 얻을 수 있습니다.

>>> print(iris.data) # data 속성을 사용해 피쳐를 알아볼 수 있습니다. 

>>> print(iris.feature_names) # feature_names 속성으로 피쳐 이름을 알아낼 수 있습니다.

이것은 데이터셋이 꽃받침 길이, 꽃받침 너비, 꽃잎 길이, 꽃잎 너비 등 4개의 컬럼들로 구성되어 있다는 것을 의미합니다.

>>> print(iris.target) # 레이블을 알 수 있습니다.

>>> print(iris.target_names) # 레이블 이름을 알 수 있습니다.

여기서 0은 'setosa'를, 1은 'versicolor'를 2는 'virginica'를 나타냅니다.

(사이킷런의 모든 샘플 데이터가 feature_names, target_names 속성을 지원하는 것은 아닙니다)

여기서, 데이터를 쉽게 다루기 위해, 판다스(Pandas)의 데이터프레임으로 변환하는 것이 유용합니다.

>>> import pandas as pd # pandas 라이브러리를 읽어들입니다.

>>> df = pd.DataFrame(iris.data) 

>>> df.head()

<캐글(Kaggle) 데이터셋 사용하기>

 데이터 과학자 및 머신러닝 학습자들에게 있어, 캐글(Kaggle)은 세계에서 가장 큰 커뮤니티입니다.

머신러닝 경쟁을 제공하는 플랫폼에서 시작하여, 현재 캐글(Kaggle)은 공개 데이터 플랫폼과 데이터 과학자를 위한 클라우드 기반 워크 벤치도 제공합니다.

구글이 2017년 3월에 캐글(Kaggle)을 인수했습니다. 

우리는 머신러닝 학습자들을 위해, 캐글(Kaggle)에서 제공된 샘플 데이터셋을 이용할 수 있습니다.

몇가지 흥미로운 데이터셋이 있는데, 다음과 같습니다.

• 여성 신발 가격들 : 10,000개의 여성 신발 리스트와 그것들이 팔린 가격들(https://www.kaggle.com/datafiniti/womens-shoes-prices)
• 중국의 낙상 감지 데이터 : 노년 환자들의 활동과 의료 정보(https://www.kaggle.com/pitasr/falldata) 
• 뉴욕시(NYC) 부동산 매매 : NYC 부동산 시장에서 1 년 동안 판매되는 부동산(https://www.kaggle.com/new-york-city/nyc-property-sales#nyc-rolling-sales.csv)
• 미국 비행 지연 : 2016년의 비행 지연(https://www.kaggle.com/niranjan0272/us-flight-delay)

<캘리포니아 대학, 어바인의 머신러닝 저장소 사용하기>

캘리포니아 대학, 어바인의 머신러닝 저장소는 머신러닝 알고리즘의 데이터 생성 경험적 분석을 위해, 머신러닝 커뮤니티에서 사용하는 데이터베이스, 도메인 이론 및 데이터 생성기 모음입니다.

이 거대한 데이터셋 모음 중에서 흥미로운 몇가지 데이터셋을 살펴보면 다음과 같습니다.

• 자동 MPG 데이터셋 : 다양한 유형의 자동차 연비에 관한 데이터 모음(https://archive.ics.uci.edu/ml/datasets/Auto+MPG)
• 학생 성과 데이터셋 : 중등 교육(고등학교)에서의 학생 성과 예상(https://archive.ics.uci.edu/ml/datasets/Student+Performance)
• 인구 조사 소득 데이터셋 : 인구조사 데이터를 기초로 소득이 년간 $ 50K를 초과하는지 예측(https://archive.ics.uci.edu/ml/datasets/census+income)

< 직접 자신의 데이터셋 생성하기>

실험을 위한 적당한 데이터셋을 찾을 수가 없다면, 직접 자신의 데이터셋을 생성합니다.

사이킷런(Scikit-learn) 라이브러리의 sklearn.datasets.samples_generator 모듈에는 다양한 유형의 문제에 대해 서로 다른 유형의 데이터 세트를 생성할 수 있는 많은 함수가 포함되어 있습니다.

다음과 같은 데이터셋들을 만들 수 있습니다.

• 선형으로 분산된 데이터셋
• 군집화된 데이터셋
• 순환 방식으로 분산되고 군집화된 데이터셋

1. 선형으로 분산된 데이터셋

make_regression() 함수를 사용해 선형으로 분산된 데이타를 생성합니다. 아웃풋에 적용된 가우스 노이즈의 표준 편차뿐만 아니라, 원하는 피쳐의 수를 지정할 수도 있습니다.

>>> % matplolib inline

>>> import matplotlib.pyplot as plt

>>> from sklearn.datasets.samples_generator import make_regression

>>> X, y = make_regression(n_samples=100, n_features=1, noise=5.4)

>>> plt.scatter(X, y)

2. 군집화된 데이터셋

make_blobs()함수는 n개의 무작위 데이터 클러스터를 생성합니다. 이것은 비지도(자율)학습에서 군집화를 수행할 때 매우 유용합니다.

>>> %matplotlib inline

>>> import matplotlib.pyplot as plt

>>> import numpy as np

>>> from sklearn.datasets import make_blobs

>>> X, y = make_blobs(500, centers=3) # 군집화를 위한 등방성 가우시안 블롭 생성

>>> rgb = np.array(['r', 'g', 'b'])

>>> plt.scatter(X[:, 0], X[:, 1], color=rgb[y]) # 산포도와 컬러 코딩을 사용해 그립니다.

3. 순환 방식으로 분산되고 군집화된 데이터셋

make_circles()함수는 두 개의 차원에 작은 원을 포함하는 큰 원이 포함된 임의의 데이터셋을 생성합니다. SVM(

Support Vector Machines)과 같은 알고리즘을 사용하여 분류(classifications)를 수행할 때 유용합니다.

>>> %matplotlib inline

>>> import matplotlib.pyplot as plt

>>> import numpy as np

>>> from sklearn.datasets import make_circles

>>> X, y = make_circles(n_samples=100, noise=0.09)

>>> rgb = np.array(['r', 'g', 'b'])

>>> plt.scatter(X[:, 0], X[:, 1], color=rgb[y])

다음 번에는 간단한 선형 회귀(linear regression) 알고리즘을 구현해 보면서 사이킷런(Scikit-Learn) 기초 사용법을 익혀 보겠습니다.

(Source : Python Machine Learning, Wiley, 2019)

머신러닝 프로젝트 실행(6~7단계)

머신러닝 프로젝트 실행 순서는 

1. 문제를 정의하고 전체 그림 바라보기

2. 데이터 얻기

3. 인사이트를 찾기 위해 데이터 탐색하기

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

5. 다양한 모델을 탐색하고 그 중 가장 좋은 모델을 찾기

6. 모델을 알맞게 튜닝하고 멋진 솔루션으로 통합하기

7. 시스템 런칭, 모니터링과 유지하기

입니다.

지금까지, 1~5단계까지 살펴보았습니다. 이제 2단계만 살펴보면 마무리 될 것 같습니다. 

먼저, 

6. 모델을 알맞게 튜닝하고 멋진 솔루션으로 통합하기

이제 유망한 모델들을 가졌다고 가정해 봅시다. 

그럼, 이 모델들을 튜닝하는 것이 필요합니다. 

실행할 수 있는 몇가지 방법을 살펴보도록 하겠습니다.

그리드 서치(Grid Search)

모델 튜닝을 수행하는 한 가지 방법은 하이퍼파라미터 값들의 좋은 조합을 찾아낼 때까지, 수동으로 하이퍼파라미터(hyperparameters)를 사용하는 것입니다. 

이것은 매우 지루한 작업이 될 것이고, 많은 조합을 탐색할만한 시간을 갖고 있지 않을 수도 있습니다.

그 대신에, 사이킷런(Scikit-Learn)의 GridSearchCV로 탐색을 하도록 할 수 있습니다. 

해야할 일 전부는 어떤 하이퍼파라미터를 실험하고 싶은지, 어떤 값들을 시험해 보아야 하는지를 알려주는 것입니다. 

그러면, 교차검증(cross-validation)을 사용해, 하이퍼파라미터 값들의 모든 가능한 조합들을 평가할 것입니다. 

예를 들어, 다음의 코드는 RnadomForestRegreesor를 위해 하이퍼파라미터 값들에 대한 최상의 조합을 검색합니다. 

>>> from sklearn.model_selection import GridSearchCV

>>> param_grid = [

{'n_estimators': [3, 10, 30], 'max_features': [2, 4, 6, 8]},

{'bootstrap': [False], 'n_estimators': [3, 10], 'max_features': [2, 3, 4]},

]

>>> forest_reg = RandomForestRegressor()

>>> grid_search = GridSearchCV(forest_reg, param_grid, cv=5,

scoring='neg_mean_squared_error')

>>> grid_search.fit(housing_prepared, housing_labels)

팁) 하이퍼파라미터가 어떤 값을 가져야 할지 알 수 없을 때, 간단한 접근법은 연속적으로 10의 파워를 시도해 보는 것입니다. (또는 더 세분화된 탐색을 원한다면, 더 작은 숫자로 시도: n_estimators 하이퍼파라미터를 가진 위 예에서 보듯이)

위 param_grid는 사이킷런에게 처음에 n_estimators의 모든 3×4 = 12개의 조합과 첫번째 dict에서 특정한 max_features 하이퍼파라미터 값들을 평가하도록 알려줍니다. 

그 다음에 두번째 dict인 모든 2×3 = 6개의 하이퍼파라미터 값들의 조합을 시도합니다. 

하지만, 이번에는 bootstrap 하이퍼파라미터는 True(이 하이퍼파라미터의 기본값이 True임) 대신에 False를 설정합니다.

전체적으로, 그리드 서치(grid search)는 RandomForestRegressor 하이퍼파라미터 값들의 12+6 =18개 조합들을 탐색할 것입니다. 

그리고 각 모델을 5번씩(왜냐하면 five-fold 교차검증을 사용하기 때문) 훈련시킬 것입니다. 

달리 말하자면 전체적으로, 18×5 = 90번의 훈련 라운드가 될 것입니다. 

아주 많은 시간이 걸리겠지만, 아래와 같이 최상의 파라미터 조합을 얻게 될 것입니다.

>>> grid_search.best_params_

{'max_features': 6, 'n_estimators': 30}

팁) n_estimators의 최대값이 30으로 평가되었습니다. 점수가 지속적으로 향상될 수도 있기 때문에, 더 높은 값도 평가해 보아야 할 것입니다.

직접 최상의 평가자(estimator)를 얻을 수도 있습니다.

>>> grid_search.best_estimator_

RandomForestRegressor(bootstrap=True, criterion='mse', max_depth=None,

max_feature=6, max_leaf_nodes=None, min_samples_leaf=1,

min_samples_split=2, min_weight_fraction_leaf=0.0,

n_estimators=30, n_jobs=1, oob_score=False, random_state=None,

verbose=0, warm_start=False)

물론 평가 점수들도 이용할 수 있습니다.

>>> cvres = grid_search.cv_results_

... for mean_score, params in zip(cvres["mean_test_score"], cvres["params"]):

...        print(np.sqrt(-mean_score), params)

...

64912.0351358 {'max_features': 2, 'n_estimators': 3}

55535.2786524 {'max_features': 2, 'n_estimators': 10}

52940.2696165 {'max_features': 2, 'n_estimators': 30}

60384.0908354 {'max_features': 4, 'n_estimators': 3}

52709.9199934 {'max_features': 4, 'n_estimators': 10}

50503.5985321 {'max_features': 4, 'n_estimators': 30}

59058.1153485 {'max_features': 6, 'n_estimators': 3}

52172.0292957 {'max_features': 6, 'n_estimators': 10}

49958.9555932 {'max_features': 6, 'n_estimators': 30}

59122.260006 {'max_features': 8, 'n_estimators': 3}

52441.5896087 {'max_features': 8, 'n_estimators': 10}

50041.4899416 {'max_features': 8, 'n_estimators': 30}

62371.1221202 {'bootstrap': False, 'max_features': 2, 'n_estimators': 3}

54572.2557534 {'bootstrap': False, 'max_features': 2, 'n_estimators': 10}

59634.0533132 {'bootstrap': False, 'max_features': 3, 'n_estimators': 3}

52456.0883904 {'bootstrap': False, 'max_features': 3, 'n_estimators': 10}

58825.665239 {'bootstrap': False, 'max_features': 4, 'n_estimators': 3}

52012.9945396 {'bootstrap': False, 'max_features': 4, 'n_estimators': 10}

위 예에서, max_features 하이퍼파라미터를 6으로, n_estimators 하이퍼파라미터를 30으로 설정함으로써 최상의 해결책을 확보할 수 있습니다. 

이 조합의 RMSE 점수는 49,959입니다. 

기본 하이퍼파라미터 값들(점수가 52,634)을 사용한 경우보다 더 좋은 점수를 얻었기 때문에 약간 더 좋아졌습니다. 

성공적으로 최상의 모델로 잘 튜닝했습니다!

팁) 하이퍼파라미터로 데이터 준비 단계 중 일부를 다룰 수 있다는 것을 잊지 마세요. 예를 들어, 그리드 서치(grid search)는 확신할 수 없는 피쳐(feature)를 추가하는 것과는 상관없이 자동적으로 찾아낼 것입니다. 자동으로 간단히 아웃라이어 핸들링, 누락된 피쳐들, 피쳐 선택 등에 대한 최상의 방법을 찾을 수 있도록 사용될 수 있을 것입니다. 

무작위 서치(Randomized Search)

그리드 서치(grid search) 접근법은 앞의 예처럼, 상대적으로 적은 조합을 탐색할 때 좋습니다. 

하지만, 하이퍼파라미터 서치 스페이스가 클때는, 그리드 서치 대신에 RandomizedSearchCV를 사용하는 것을 더 선호합니다. 

이 클래스는 GridSearchCV 클래스와 매우 유사한 방법으로 사용할 수 있습니다. 

하지만 모든 가능한 조합들을 시도하는 대신에, 매 반복시마다 각 하이퍼파라미터에 대해 랜덤한 값을 선택함으로써 주어진 숫자만큼 무작위 조합에 대해 평가합니다. 

이 접근법은 두가지 주요 혜택이 있습니다.

• 만약 1,000회 반복하도록 무작위 서치를 실행한다면, 이 접근법은 각각의 하이퍼파라미터에 대해 1,000개의 다른 값들을 탐색할 것입니다. (그리드 서치 접근법에서는 각각의 하이퍼파라미터에 대해 단지 몇개의 값들을 탐색)

• 간단히 반복할 숫자를 설정함으로써, 하이퍼파라미터 검색에 할당할 컴퓨팅 자원을 더 잘 컨트럴할 수 있습니다. 

앙상블 메서드(Ensemble Methods)

시스템을 튜닝하기 위한 또 다른 방법은 가잘 잘 수행할 수 있는 모델들을 결합시켜 보는 것입니다. 

그 그룹(또는 "앙상블")은 최상의 개별 모델보다 더 잘 수행할 것입니다(랜덤 포레스트가 의지하는 개별 결정 트리 보다 랜덤 포레스트가 더 잘 수행하는 것과 같음). 

특히, 개별 모델이 매우 다른 형태의 오류를 만드는 경우 더 그렇습니다. 

최고의 모델과 그 모델의 에러 분석하기

가장 좋은 모델을 검사하여 문제에 대한 좋은 통찰을 얻을 수 있습니다. 

예를 들어, RandomForestRegressor은 정확한 예측을 하기 위해, 각 속성의 상대적 중요성을 나타낼 수 있습니다:

>>> feature_importances = grid_search.best_estimator_.feature_importances_

>>> feature_importances

array([  7.14156423e-02,   6.76139189e-02,   4.44260894e-02,

1.66308583e-02,  1.66076861e-02,   1.82402545e-02,

1.63458761e-02,   3.26497987e-01,   6.04365775e-02,

1.13055290e-01,   7.79324766e-02,   1.12166442e-02,

1.53344918e-01,   8.41308969e-05,   2.68483884e-03,

3.46681181e-03])

해당 속성의 이름 옆에 중요도 점수를 표시합시다:

>>> extra_attrivs = ["rooms_per_hhold", "pop_per_hhold", "bedrooms_per_room"]

>>> cat_one_hot_attribs = list(encoder.classes_)

>>> attributes = num_attribs + extra_attribs + cat_one_hot_attribs

>>> sorted(zip(feature_importances, attributes), reverse=True)

[(0.32649798665134971, 'median_income'),

(0.15334491760305854, 'INLAND'),

(0.11305529021187399, 'pop_per_hhold'),

(0.07793247662544775, 'bedrooms_per_room'),

(0.071415642259275158, 'longitude'),

(0.067613918945568688, 'latitude'),

(0.060436577499703222, 'rooms_per_hhold'),

(0.04442608939578685, 'housing_median_age'),

(0.018240254462909437, 'population'),

(0.01663085833886218, 'total_rooms'),

(0.016607686091288865, 'total_bedrooms'),

(0.016345876147580776, 'households'),

(0.011216644219017424, '<1H OCEAN'),

(0.0034668118081117387, 'NEAR OCEAN'),

(0.0026848388432755429, 'NEAR BAY'),

(8.4130896890070617e-05, 'ISLAND')

이 정보를 가지고, 유용하지 않은 피쳐들(features) 일부를 탈락시키고 싶을 수도 있습니다(예,. 분명히 하나의 ocean_proximity 범주만이 정말 유용합니다. 그래서 다른 것들에 대한 탈락을 시도할 수 있습니다).

또한, 시스템에서 발생시키는 특정 에러를 살펴보아야만 합니다. 

그런 다음, 발생 원인을 이해하도록 해야 하고, 그 문제를 어떻게 고칠 수 있는지도 이해해야 합니다(다른 피쳐들을 추가하거나 반대로 불필요한 피쳐들을 제거하고, 아웃라이어를 클리닝 하는 등). 

테스트 셋에서 시스템 평가하기

잠시동안 모델을 조정한 후에, 결국 효율적으로 잘 수행하는 시스템을 갖게 되었습니다. 

이제 최종 모델을 테스트 셋에서 평가해 볼 시간입니다. 

이 프로세스에 있어 특별한 것은 없습니다; 단지 테스트 셋에서 예측변수(predictors)와 레이블을 가져와, 데이터를 변환(fit_transform()이 아니라 transform()을 호출!)하기 위해 full_pipeline을 실행합니다. 그리고, 테스트 셋에서 최종 모델을 평가합니다:

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

많은 하이퍼파라미터를 튜닝했다면, 성능은 보통 교차 검증(cross-validation)을 사용해 측정한 것보다 조금 나쁠 겁니다

(왜냐하면, 검증 데이터에서 잘 수행되도록 미세 조정되었기 때문에, 알려지지 않은 데이터셋에서는 잘 수행되지 않을 것입니다). 

이 예에서는 그렇지 않습니다만, 이런 경우가 생기면 테스트 셋에서 숫자가 잘 나올 수 있도록 하이퍼파라미터를 조정하는 유혹에 빠지면 안됩니다; 그 개선은 새로운 데이터에 일반화될 것 같지 않기 때문입니다.

이제 프로젝트가 시작되는 시점이 되었습니다: 해결책을 제시하는 것(학습한 것을 강조 표시하고, 무엇이 작동되고 무엇이 안되는지, 어떤 가정들이 만들어 졌는지, 그리고 이 시스템의 한계는 무엇인지), 모든 것을 문서화하고, 분명한 시각화와 쉽게 기억할 수 있는 문구를 가진 멋진 프리젠테이션을 만드는 것이 필요합니다(예,. "중앙 소득은 주택 가격의 가장 중요한 예측 변수 입니다").

7. 시스템 런칭, 모니터링과 유지하기

이제 제품화를 위한 솔루션 준비가 필요합니다. 

특히, 제품을 가동함으로써 시스템에 데이터 소스를 입력하고 테스트를 작성하기 위한 준비가 필요합니다.

또한, 시스템을 정기적으로 실제 사용중에 점검할 수 있는 모니터링 코드를 작성하는 것도 필요합니다. 

문제가 생기면 경고도 날려줘야 합니다. 

이것은 갑작스런 작동중단 뿐 아니라, 성능 저하를 잡아내는 데 있어 중요합니다. 

모델은 정기적으로 새로운 데이터로 훈련되지 않으면, 시간이 지남에 따라 모델의 데이터가 "망가지는" 경향이 있기 때문에 매우 일반적입니다.

시스템의 성능을 평가하려면 시스템의 예측을 샘플링하고 그것들을 평가해야 합니다. 이것은 일반적으로 사람의 분석을 요구합니다. 이 분석가들은 현장 전문가일 수도 있고, 크라우드소싱 플랫폼의 작업자일 수도 있습니다(Amazon Mechanical Turk 또는 CrowdFlower 같은). 어느 쪽이든, 사람의 평가 파이프라인을 시스템에 연결해야 합니다. 

또한, 시스템의 입력 데이터 품질을 평가해야 합니다. 

때때로 나쁜 품질 시그널(예., 오작동하는 센서가 무작위 값들을 보내거나, 다른 팀의 결과가 부실해지거나)때문에, 성능이 약간씩 떨어질 것입니다. 

하지만, 시스템 성능 저하에 따른 경고를 받기까지는 딜레이 시간이 걸리 수 있습니다. 

만약 시스템의 입력을 모니터하고 있다면, 이 경고를 더 일찍 잡아낼 수 있습니다. 

특히 입력 모니터링은 온라인 학습 시스템에서 중요합니다.

마지막으로 말할 것은, 일반적으로 새로운 데이터를 가지고 정기적으로 모델을 훈련시키는 것을 원할 것이라는 것입니다.

가능한 한 이 프로세스를 자동화해야 합니다. 

그렇지 않으면, (적어도) 6개월마다 시스템을 고칠 가능성이 큽니다. 

그리고 시스템 성능은 시간이 지남에 따라 크게 변동될 수 있습니다. 

만약 온라인 학습 시스템이라면, 일정한 간격으로 상태 시냅샷을 저장해야만 할 것입니다. 

그렇게 해서, 쉽게 이전의 작동 상태로 되돌아갈 수 있습니다. 

여기까지가 예제를 가지고 학습해 본 머신러닝 프로젝트 실행에 대한 전체 프로세스였습니다. 

여러 번 읽어보고 익혀야 이해가 될 것 같네요. 

앞으로 저도 지금까지 설명한 절차대로 http://kaggle.com과 같은 사이트에서 실습을 진행해 보고 싶습니다.

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

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

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

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

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

(4단계: 4. 기본 데이터 패턴을 머신러닝 알고리즘에 더 잘 노출시킬 수 있도록 데이터 준비하기) 바로가기

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

(5단계: 5. 다양한 모델을 탐색하고 그 중 가장 좋은 모델 찾기) 바로가기

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

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

이번에는 머신러닝 프로젝트 4단계에 이어, 5단계를 살펴보도록 하겠습니다.

5. 다양한 모델을 탐색하고 그 중 가장 좋은 모델 찾기

지금까지 문제를 정의하고, 데이터를 얻어서 탐색해 보았습니다. 

그리고 트레이닝 셋과 테스트 셋을 샘플링하고, 자동적으로 머신러닝 알고리즘을 위해 클리닝해서 데이터를 준비하기 위해 변형 파이프라인을 작성했습니다. 

이제 머신러닝 모델을 선택해서 트레이닝시킬 준비가 되었습니다.

트레이닝 셋에서 훈련하고 평가하기

좋은 소식은 이전 1~4단계 덕분에, 이제 생각했던 것보다 상황이 훨씬 간단하게 진행될 것이라는 것입니다. 

우선 선형 회귀 모델을 트레이닝해 봅시다.

>>> from sklearn.linear_model import LinearRegression

>>> lin_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("Predictions:\t", lin_reg.predict(some_data_prepared))

Predctions:    [    303104.    44800.    308928.    294208.    368704. ]

>>> print("Labels:\t\t", list(some_labels))

Labels:        [359400.0,  69700.0,  302100.0,  301300.0,  351900.0]

예측이 아주 정확하지는 않지만 작동합니다

(두번째 예측이 50% 이상 차이가 있습니다!). 

사이킷런(Scikit-Learn)의 mean_squared_error 함수를 사용해서 전체 트레이닝 셋에 대한 이 회귀 모델의 RMSE를 측정해 봅시다.        

교차검증(Cross-Validation)을 사용해 더 좋은 평가 만들기

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

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

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

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

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

데이터 클리닝

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

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

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

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

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

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

변환 파이프라인(Pipeline)

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

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

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

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

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

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

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

3. 인사이트를 찾기 위해 데이터 탐색하기

1~2단계에서는 지금까지 처리하는 데이터의 종류에 대한 일반적인 이해를 얻기 위해 데이터를 훑어보았습니다. 

지금부터는 조금 더 깊이 들어가 보도록 하겠습니다.

먼저, 테스트 셋을 별도로 마련해 두었는지 확인하고, 훈련 셋을 탐색해 보도록 합시다. 만약 훈련 셋이 아주 크다면, 쉽고 빠르게 데이터를 다루기 위해 탐색하기 위한 셋을 샘플링하고 싶을지도 모릅니다. 우리 데이터의 경우에는, 훈련 셋이 매우 작기 때문에 전체 셋에서 직접 작업을 할 수 있습니다. 

카피본을 만들어, 훈련 셋에 영향을 주지 않고 작업을 시작해 봅시다.

>>> housing = strat_train_set.copy()

지리 데이터를 시각화하기

지리 정보(위도와 경도)가 있기 때문에, 데이터를 시각화하기 위해 모든 지구의 산포도를 만들어 보는 것은 좋은 아이디어입니다.

>>> housing.plot(kind="scatter", x="longitude", y="latitude")

이것은 캘리포니아처럼 보입니다. 하지만, 어떤 특정 패턴을 보기는 어렵습니다. alpha 옵션(투명도)을 0.1로 설정하면 데이터 포인트가 고밀도인 곳이 어느 지역인지 더 쉽게 시각화할 수 있습니다.

>>> housing.plot(kind="scatter", x="longitude", y="latitude", alpha=0.1)

이제 더 좋아 보입니다. 

즉 베이지역과 로스앤젤레스, 샌디에이고 같은 고밀도 지역을 분명하게 구분할 수 있습니다. 샌트럴 밸리 특히 새크래멘토와 프레스노 주변은 상당히 고밀도의 긴 선을 보여주고 있습니다.

일반적으로, 우리 두뇌는 그림에서 얼룩진 패턴을 인식하는데 매우 우수합니다. 하지만, 패턴을 눈에 띄게 만들기 위해 시각화 파라미터를 가지고 더 작업이 필요할 수도 있습니다. 

자, 집값을 보도록 합시다. 

각 원의 반경은 지구의 인구수를 나타냅니다. 그리고 색깔은 가격을 나타냅니다. 여기서는 jet(낮은 값은 푸른색, 높은 값은 붉은색으로 표시)라 불리는 미리 정의된 색깔 맵을 사용할 것입니다. 

>>> housing.plot(kind="scatter", x="longitude", y="latitude", alpha=0.4, s=housing["population"]/100, label="population", c="median_house_value", cmap=plt.get_cmap("jet"), colorbar=True)

>>> plt.legend()

이 이미지는 집값이 위치(예를 들자면, 해안과 가까운) 및 인구 밀도와 매우 밀접한 관계가 있다고 알려줍니다. 아마도 중심 클러스터를 탐지하기 위해 클러스터링 알고리즘을 사용하는 것이 유용할 수도 있습니다. 그리고, 클러스터 센터를 더 근접 측정하기 위해 새로운 피처들(features)을 추가할 수도 있습니다. 해안 근접 속성이 유용할 수 있지만, 북부 캘리포니아의 해안 지구 집값이 높지 않기 때문에, 규칙이 간단하지만은 않습니다.

상관관계 찾기

데이터셋이 아주 크지 않기 때문에, 모든 속성 쌍에서 corr() 메소드를 사용해 표준 상관 계수(Pearson's r이라 불림)를 쉽게 계산할 수 있습니다.

>>> corr_matrix = housing.corr()

중간 집 값과 각 속성들이 얼마나 상관관계가 있는 보도록 합시다.

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

median_house_value        1.000000

median_income              0.687170

total_rooms                  0.135231

housing_median_age        0.114220

households                   0.064702

total_bedrooms              0.047865

population                  -0.026699

longitude                   -0.047279

latitude                     -0.142826

Name: median_house_value, dtype: float64

상관 계수의 범위는 -1에서 1사이입니다. 

1에 가깝다는 것은 강한 양의 상관관계가 있다는 것을 의미합니다: 예를 들어, 중간 소득이 올라갈 때, 중간 집 값이 올라가는 경향이 있습니다. 상관관계가 -1에 가깝다는 것은, 강한 음의 상관관계가 있다는 것을 의미합니다: 위도와 중간 집 값은 작은 음의 상관관계가 있다는 것(예, 북쪽으로 갈수록 집 가격이 약간 낮아지는 경향이 있습니다)을 알 수 있습니다. 마지막으로, 계수가 0에 가깝다는 것은 선형 상관관계가 없다는 것을 의미합니다. 

다음의 이미지들은 수평 및 수직 축 사이의 상관 계수에 대한 다양한 플롯을 보여줍니다.

(출처 : 위키피디아, public domain image)

속성들 사이의 상관관계를 점검하는 또 다른 방법은 판다스(Pandas)의 scatter_matrix 함수를 사용하는 것입니다. 이 함수는 모든 수치 속성을 모든 다른 수치 속성들에 대비한 플롯해 보여줍니다. 지금 11개의 수치 속성들이 있기 때문에, 121개의 플롯들을 얻게 될 것입니다. 여기서는 중간 집값과 가장 좋은 상관관계를 보여주는 몇가지 속성들에만 집중하도록 합니다.

>>> from pandas.tools.plotting import scatter_matrix

>>> attributes = ["median_house_value", "median_income", "total_rooms", "housing_median_age"]

>>> scatter_matrix(housing[attributes], figsize=(12, 8))

메인 대각선(왼쪽 위에서 오른쪽 아래)에는 각 속성에 대한 히스토그램을 보여줍니다. 이는 동일 속성에 대해 상관관계를 보여주는 것은 의미가 없기 때문입니다. 

중간 집값과 가장 상관관계가 높은 속성은 중간 소득입니다. 그 상관관계 산포도를 확대해 보도록 합시다.

>>> housing.plot(kind="scatter", x="median_income", y= "median_house_value", alpha=0.1)

이 플롯은 몇가지를 나타냅니다. 

첫째, 실제 상관관계가 매우 강하다는 것입니다; 상향 트렌드를 분명하게 볼 수 있고, 포인트들이 많이 분산되지도 않았습니다. 

둘째, 처음에 알고 있던 가격 상한선이 $500,000 수평선에 분명하게 보입니다. 하지만, 이 플롯은 또 다른 분명한 직선들을 보여줍니다: $450,000 주변 수평선, $350,000 주변 수평선, 아마도 $280,000 주변 수평선과 더 아래의 일부. 

이러한 데이터 단점을 재현하도록 알고리즘이 학습되는 것을 방지하기 위해 대응하는 지구를 제거해야 할지도 모릅니다.

속성 조합으로 시험하기

잘하면 이전 섹션의 몇 가지 방법을 통해 데이터를 탐색한 후 인사이트를 얻을 수 있습니다. 

머신러닝 알고리즘에 데이터를 피딩(feed)하기 전에 청소하고 싶어할 몇가지 데이터 단점을 알게 되었습니다. 그리고 타겟 속성과 다른 속성들 사이의 흥비로운 상관관계를 발견했습니다. 또한 몇몇 속성들은 편향된 분포도를 가지고 있다는 것을 알 수 있었고, 이것들을 변환(예, 그 속성들의 로그를 계산해서 표준 분포로)해야할지도 모릅니다. 물론, 각 프로젝트마다 수고해야 하는 노고는 각기 다릅니다만, 일반적인 아이디어는 유사합니다.

머신러닝 알고리즘을 위해 데이터를 실제 준비하기 전에 해야할 마지막 일은 다양하게 속성 조합을 시도해 보는 것입니다. 

예를 들어, 얼마나 많은 가정이 있는지 알지 못한다면, 각 지구의 전체 방수는 유용하지 않습니다. 정말 원하는 것은 각 가정의 방수입니다. 유사하게, 전체 침실수 자체로는 유용하지 않습니다. 아마도 침실수를 방숫자와 비교하고 싶어할 것입니다. 그리고 각 가정별 인구수 역시 흥미로운 속성 조합처럼 보입니다. 이들 새로운 속성들을 만들어 보도록 합시다.

>>> housing["rooms_per_household"] = housing["total_rooms"]/housing["househods"]

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

median_house_value            1.000000

median_income                  0.687170

rooms_per_household           0.199343

total_rooms                      0.135231

housing_median_age            0.114220

households                       0.064702

total_bedrooms                  0.047865

population_per_household     -0.021984

population                      -0.026699

longitude                       -0.047279

latitude                         -0.142826

bedrooms_per_room            -0.260070

Name: median_house_value, dtype: float64

새로운 bedrooms_per_room 속성이 중간 집값과 가장 높은 상관관계를 보여줍니다. 분명히 더 적은 침실/전체방 비율을 가진 집들이 더 비싼 경향이 있습니다. 각 가정별 방수 또한 지구내 전체 방수보다 더 많은 정보를 제공합니다- 분명히 집들이 더 클수록 더 비쌉니다.

이 라운드의 탐색은 아주 철저하지 않아도 됩니다; 포인트는 올바른 출발점을 찾는 것이고 합리적으로 좋은 프로토타입을 얻기 위한 인사이트를 빠르게 얻는 것입니다. 하지만 이것은 반복적인 절차입니다: 한번 프로토타입을 얻어서 실행한 후, 더 많은 인사이트를 얻기 위해 그 결과물을 분석할 수 있습니다. 그런 다음 이 탐색 단계로 다시 돌아올 수 있습니다.

생각보다 공부한 것을 정리하는 것이 쉬운 작업이 아니네요. 조금식 꾸준히 하는 것이 한꺼번에 많이 하는 것보다 더 좋다고 생각해서 자주 한 단계씩 정리하도록 할 계획입니다.

"4. 기본 데이터 패턴을 머신러닝 알고리즘에 더 잘 노출할 수 있도록 데이터 준비하기"는 다음 글로 정리하겠습니다.

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

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

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

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

요즘 읽고 있는 ML책 중, 예제를 통해 머신러닝 프로젝트 실행 프로세스를 처음부터 끝까지 배우는 부분이 있어, 정리해 봅니다.

머신러닝을 배우는 데 있어 실제 세상의 데이터를 가지고 프로젝트를 수행해 보는 것이 최상일 것입니다. 실제 데이터를 미국에서는 정말 많이 공짜로 제공하고 있습니다. 실 데이터를 가지고 머신러닝 실습을 하게 되면 무척 도움이 많이 될 것입니다.

우선 내용이 길어 글을 나눠서 올리도록 하겠습니다. 

전체 순서는

1. 문제를 정의하고 전체 그림 바라보기

2. 데이터 얻기

3. 인사이트를 찾기 위해 데이터 탐색하기

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

5. 다양한 모델을 탐색하고 그 중 가장 좋은 모델을 찾기

6. 모델을 알맞게 튜닝하고 멋진 솔루션으로 통합하기

7. 시스템 런칭, 모니터링과 유지하기

순입니다.

이번에는 1~2번까지 정리해서 올리도록 하겠습니다. 

참고로, 오픈 데이터셋 중에서 가장 인기있는 3곳의 링크는 아래와 같습니다. 

다른 곳도 있지만, 이곳을 가장 많이 애용한다고 하네요.

UC Irvine Machine Learning Repository (http://archive.ics.uci.edu/ml/)

Kaggle datasets (https://www.kaggle.com/datasets)

Amazon's AWS datasets (https://aws.amazon.com/fr/datasets/)

그럼, 지금부터  StatLib repository의 캘리포니아 집값 데이터셋을 가지고 머신러닝 프로젝트를 만들어 볼 것입니다. 

이 데이터셋은 1990년의 캘리포니아 인구조사 데이터를 기반으로 하고 있습니다. 

1. 문제를 정의하고 전체 그림 바라보기

첫번째 해야 할 일은 캘리포니아 인구조사 데이터를 사용해 캘리포니아 집값 모델을 만드는 것입니다. 이 데이터는 캘리포니아의 각 블록 그룹에 대한 인구, 중간 소득, 중간 집값 등 같은 메트릭스로 구성되어 있습니다. 블록 그룹은 미국 인구조사국이 제공하는 가장 작은 지리적 유닛(블록 그룹은 통상 600~3,000명의 사람들로 구성)입니다. 우리는 간단히 '지구(districts)'라고 부를 것입니다. 

그럼 이제 정확하게 이 데이터를 가지고 무엇을 하려고 하는 것인지를 분명히 하는 것으로 시작해야 합니다. 문제를 어떻게 정하느냐에 따라 문제를 정의하고 어떤 알고리즘을 선택해서, 성능을 측정할지가 정해지기 때문입니다. 

여기서는 주어진 데이터를 통해 지구별 가격을 예측해서, 어느 곳에 투자하는 것이 이익을 가장 많이 얻을 수 있는지 알아보는 것을 문제로 정했습니다.

그 다음 확인할 사항은 현재 실행되고 있는 해결 방안이 어떻게 이루어지고 있는지 파악하는 것입니다. 

여기서는 현재 지역별 집값을 전문가들이 직접 측정하고 있다고 합니다: 지구별 최신 정보를 팀이 모으고, 측정을 위해 복잡한 규칙을 적용합니다. 이것은 비용과 시간이 소모되고, 측정값이 훌륭하지도 않습니다; 통상 에러율이 약 15% 수준입니다.

이 모든 정보를 가지고 이제 시스템 디자인을 시작합니다. 

첫째, 문제에 대한 프레임이 필요합니다: 지도학습, 비지도학습, 또는 강화학습? 분류 업무, 회귀 업무, 또는 그 밖에 다른? 배치 학습 또는 온라인 러닝 기술을 사용해야 하는지? 등을 결정해야 합니다.

이것은 분명히 라벨링된 훈련 예제들(각 인스턴스들은 기대되는 아웃풋과 함께 제시, 예를 들어 각 지구의 중간 집값)이 주어진 통상적인 지도학습 업무입니다. 게다가, 값을 예측해야 하기 때문에 전형적인 회귀 업무입니다. 더 특별하게는, 이 시스템이 다양한 피처들(features)을 사용해서 예측을 만들기 때문에 다변량 회귀 문제입니다(지역별 인구, 중간 수익값 등을 사용할 것입니다). 마지막으로 빠르게 변화하는 데이터를 반영할 필요가 없고, 데이터도 메모리에서 처리가 적당할 정도로 적기 때문에, 배치 러닝을 사용하는 것으로도 충분할 것입니다. 

* 데이터가 크다면, 멀티 서버를 통해 배치 러닝 작업을 분할할 수도 있습니다(예를 들어 MapReduce 기술을 사용). 또는 온라인 러닝 기술을 사용할 수도 있습니다.

다음 단계는 성능 측정을 선택하는 것입니다. 회귀 문제에 대한 전형적인 성능 측정은 시스템이 만든 예측값들의 에러들에 대한 표준 편차를 측정하는 RMSE (Root Mean Square Error)를 사용합니다. 예를 들어, RMSE가 50,000과 같다는 것은 시스템이 예측한 68%가 실제 50,000에 포함된다는 의미입니다. 그리고 예측값의 95%가 실제 100,000 값들에 포함된다는 것입니다. 

RMSE가 일반적으로 회귀 업무에 있어 선호되는 성능 측정이긴 하지만, 몇몇 문맥에서 다른 기능을 사용하는 것을 선호할 수 도 있습니다. 예를 들어, 특이값을 갖는 지구가 많이 있다고 가정해 보자. 그러한 경우에, Mean Absolute Error(MAE)를 사용하는 것도 고려해 볼 수 있습니다. 

RMSE와 MAE 모두 두개의 벡터값 거리를 측정하는 방법들입니다: 예측 벡터와 타겟값 벡터. 다양한 거리 측정, 또는 규칙들이 가능합니다.

마지막으로, 지금까지 만들어진 가정들을 리스트하고 검증합니다. 이를 통해 심각한 이슈사항을 찾을 수 있습니다. 예를 들어, 시스템 아웃풋인 각 지구별 값을 정확하게 예측하는 것보다 카테고리(예, 싼, 중간, 비싼)로 가격을 변환해서 처리하는 것이 더 나을 수도 있습니다. 이럴 경우, 이 문제는 회귀 업무가 아니라, 분류 업무로 재정의되어야 할 것입니다. 몇 달 동안 회귀 시스템 구축을 추진한 후에 분류 업무로 처리해야 한다는 말을 듣고 싶지는 않을 것입니다. 그렇기 때문에, 초기에 피드백을 받는 것이 중요합니다.

2. 데이터 얻기

자, 이제 손을 사용해 봅시다. 

바로 랩탑을 열고 Jupyter 노트북에서 다음의 코드 예제를 열어봅시다.

먼저, 파이썬을 인스톨해야 합니다(이미 다 했겠죠?). 

다음으로는 머신러닝 코드와 데이터셋을 위한 작업 디렉토리가 필요합니다. 더 필요한 라이브러리들은 다음과 같습니다: Jupyter, Numpy, Pandas, Matplotlib, Scikit-Learn.  여기서는 이미 다 설치했다고 가정하겠습니다.

(Jupyter notebook 환경에서 실행하는 것을 가정했습니다. 다른 환경에서는 아래 코드가 제대로 실행되지 않을 수 있습니다)

>>> import os

>>> import tarfile

>>> from six.moves import urllib

>>> DOWNLOAD_ROOT = "https://raw.githubusercontent.com/ageron/handon-ml/master/"

>>> HOUSING_PATH = "datasets/housing"

>>> HOUSING_URL = DOWNLOAD_ROOT + HOUSING_PATH + "/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()를 불러오면, 작업 디렉토리에 datasets/housing 폴더를 만들고, housing.tgz파일을 다운로드 합니다. 그리고, 이 디렉토리에 housing.csv파일을 압축해제 합니다.

그 다음에 pandas를 사용해 데이타를 로드해 봅시다. 데이터를 불러오기 위해 다음 코드를 씁니다

>>> import pandas as pd

>>> def load_housing_data(housing_path=HOUSING_PATH):

csv_path = os.path.join(housing_path, "housing.csv")

return pd.read_csv(csv_path)

위 함수는 모든 데이터를 포함한 pandas 데이타프레임을 불러옵니다.

그 다음에 데이터 구조를 빠르게 살펴봅니다.

>>> housing = load_housing_data()

>>> housing.head()

각 열은 하나의 특정 속성을 나타냅니다. 여기에는 10개의 속성들이 있습니다 : longitude, latitude, housing_median_age, total_rooms, total_bedrooms, population, households, median_income, median_house_value, ocean_proximity.

>>> housing.info()

 이 데이터셋에는 총 20,640개의 레코드들이 있습니다. 머신러닝 표준에서는 매우 적은 수의 데이터들입니다. 그러나, 처음 시작하기에는 완벽합니다. 

info()로 확인한 바에 의하면, bedrooms 속성이 20,433개의 non-null 값을 가지고 있습니다. 이것은 207개의 레코드의 값이 없다는 것을 의미합니다. 그리고 모든 속성들이 숫자들입니다. ocean_proximity를 제외하구요. ocean_proximity의 type은 object로 파이썬의 어떤 object라도 담을 수 있습니다. 위 head()를 잘 살펴보았다면, ocena_proximity가 text속성을 가지고 잇다는 것을 알 수 있을 것입니다. 또한, 이 컬럼의 값이 반복된다는 것을 알아챘다면, value_counts() 메소드를 통해 각 카테고리에 얼마나 많은 값들이 있는지 알아낼 수 있을 것입니다.

>>> housing["ocean_proximity"].value_counts()

<1H OCEAN        9136

INLAND              6551

NEAR OCEAN     2658

NEAR BAY          2290

ISLAND                     5

Name: ocean_proximity, dtype: int64

다른 필드를 봅시다. 

describe() 메서드는 숫자 속성들의 요약을 보여줍니다.

>>> housing.describe()

count, mean, min과 max 열은 자명합니다. null 값들이 무시된 것을 주의하시기 바랍니다(예를 들어, total_bedrooms의 count는 20,640이 아니라 20,433입니다). 25%, 50%와 75% 열은 해당 백분위 수를 보여줍니다. 예를 들어, housing_median_age의 25%는 18보다 작다는 것을 알려줍니다. 50%는 29보다, 75%는 37보다 작습니다. 이것은 흔히 25th 백분위(또는 1  분위수), 중앙값, 그리고 75th 백분위(3 분위수)로 불립니다.

지금 다루고 있는 데이터 형태를 느끼기 위한 빠른 다른 방법은 각 숫자 속성에 대한 히스토그램을 그리는 것입니다. 

>>> %matplotlib inline # 주피터 노트북에서만 가능합니다.

>>> import matplotlib.pyplot as plt

>>> housing.hist(bins=50, figsize=(20,15))

>>> plt.show()

 (주피터 노트북에서 위의 명령어를 입력하고 실행해야 Matplotlib를 백그라운드에서 쉽게 이용할 수 있습니다) 

위 히스토그램에서, median_income 속성은 미국달러로 표현된 것처럼 보이지 않습니다. 머신러닝에서는 보통 전처리된 속성들로 작업합니다. 그래서, 문제가 되지는 않습니다만, 데이터가 어떻게 계산되었는지 파악하려는 노력을 해야만 합니다.

housing_median_age와 median_house_value값 모두 상한선이 있습니다. 이것이 문제가 될지 안될지 점검하는 것이 필요합니다. 

많은 히스토그램들의 꼬리가 깁니다. 중앙값보다 오른쪽으로 더 많이 깁니다. 이것은 몇몇 머신러닝 알고리즘에 있어 패턴을 인식하는데 더 어려움을 줄 수 있습니다. 나중에 이들 속성들이 종 모양의 분포를 가질 수 있도록 속성들에 변형을 주도록 할 것입니다.

테스트 셋 만들기

이론적으로 테스트 셋을 만드는 것은 매우 간단합니다 : 랜덤하게 몇몇 인스턴스를 선택합니다. 통상 데이터셋의 20%를 선택해서, 따로 설정해 둡니다.

>>> import numpy as np

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

16512 train + 4128 test

이것이 동작하긴 하지만, 완벽하지는 않습니다. 만약 이 프로그램을 다시 작동시키면, 이것은 다른 테스트 셋을 생성할 것입니다! 하나의 해결책은 처음 작동시에 테스트 셋을 저장하는 것입니다. 다른 옵션은 np.random.permutation()을 호출하기 전에 랜덤 숫자 제너레이터 씨드를 설정(예를 들어, np.random.seed(42))하는 것입니다. 그러면 항상 동일한 수치들은 생성할 것입니다.

위 두개의 해결책은 다음 번 업데이트된 데이터셋을 패치할 때 깨질 것입니다. 일반적인 해결책은 테스트 셋에 가야할 지 말아야 할지를 결정하기 위해 각 인스턴스의 식별자(인스턴스들이 고유하고 불변의 식별자를 가지고 있다고 가정)를 사용하는 것입니다. 예를 들어, 각 인스턴스의 식별자의 해시를 계산하고, 그 해시의 마지막 바이트만 간직합니다. 그리고 그 값이 51(256의 20%)보다 작거나 같다면 테스트 셋에 그 인스턴스를 집어넣습니다. 이렇게 하면 여러번 실행되는 동안, 데이타셋을 리프레시할 때 조차도 테스트 셋이 일관성을 유지하게 됩니다. 새로운 테스트 셋은 새로운 인스턴스의 20%를 포함할 것입니다. 하지만, 이전 트레이닝 셋의 어떤 인스턴스도 포함하지 않습니다. 아래 실행 가능한 코드가 있습니다.

>>> import hashlib

>>> def test_set_check(identifier, test_ratio, hash):

return hash(np.int64(identifier)).digest()[-1] < 256 * test_ratio

>>> def split_train_test_by_id(data, test_ratio, id_column, hash=hashlib.md5):

ids = data[id_column]

in_test_set = ids.apply(lamda id_: test_set_check(id_, test_ratio, hash))

return data.loc[~in_test_set], data.loc[in_test_set] 

불행히도, housing 데이타 셋은 식별자 컬럼을 가지고 있지 않습니다. 간단한 해결책은 ID로써 열 인덱스를 사용하는 것입니다.

>>> housing_with_id = housing.reset_index() # '인덱스'컬럼 추가

>>> train_set, test_set = split_train_test_by_id(housing_with_id, 0.2, "index")

만약 고유한 식별자로 열 인덱스를 사용한다면, 새로운 데이터가 데이터 셋 마지막에 추가되는 것을 확인하는 것이 필요합니다. 그리고 어떤 열도 삭제되지 않아야 합니다. 이것이 불가능하다면, 고유한 식별자를 만들기 위해 가장 안정적인 피처를 사용하도록 해봐야 할 것입니다. 예를 들어, 지구(district)의 위도와 경도가 수백년 동안 안정된 것으로 보장될 것입니다. 그래서 이 둘을 ID로써 병합할 수 있습니다. 

>>> housing_with_id["id"] = housing["longitude"] * 1000 + housing["latitude"]

>>> train_set, test_set = split_train_test_by_id(housing_with_id, 0.2, "id")

사이킷런(Scikit-Learn)은 다양한 방법으로 데이터셋을 여러 개의 서브 셋으로 나누는 함수들을 제공합니다. 가장 간단한 함수가 train_test_split입니다. 앞에서 정의한 split_train_test 함수와 매우 많은 부분이 동일합니다. 

>>> from sklearn.model_selection import train_test_split

>>> train_set, test_set = train_test_split(housing, test_size=0.2, random_state=42)

지금까지 순수 랜덤 샘플링 메서드를 살펴보았습니다. 이것은 데이터셋이 충분히 크다면(특히 속성들의 수와 비례해서), 일반적으로 훌륭합니다. 그러나 그렇지 않은 경우에는 상당한 샘플링 편차가 발생할 수 있습니다. 설문조사 회사가 1,000명에게 설문을 돌릴 때, 단순히 전화번호부에서 무작위로 1,000명을 뽑지는 않습니다. 예를 들어, 미국 인구는 51.3%의 여성과 48.7%의 남성으로 구성되어 있습니다. 그래서 미국에서 잘 만든 설문조사는 샘플에서 이 비율(513명의 여성과 487명의 남성)을 유지하려고 할 것입니다. 이것을 층화(stratified) 샘플링이라 부릅니다: 인구는 지층이라 불리는 균질한 하위 집단으로 나뉘어 집니다 . 테스트 셋이 전체 모집단을 대표할 수 있도록 하기 위해 각 계층에서 올바른 숫자의 인스턴스들이 샘플링됩니다. 만약 순수 랜덤 샘플링 메서드를 사용했다면, 49% 여성보다 더 적거나 54% 여성보다 더 많은 편향된 테스트 셋을 샘플링할 확률이 12%나 됩니다. 어느 쪽이든, 설문조사 결과가 상당히 편향될 것입니다. 

전문가들이 중간(median) 집값을 예측하기 위해 중간(median) 소득이 매우 중요한 속성이라고 말했다고 가정해 봅시다. 테스트 셋이 전체 데이터셋의 다양한 카테고리의 소득들을 대표하는 것이 확실하기를 원할 것입니다. 중간(median) 소득이 연속된 숫자 속성이기 때문에, 최초에 수입 카테고리 속성을 만드는 것이 필요합니다. 중간(median) 소득 히스토그램을 더 자세히 들여다 봅시다.

대부분의 중간 소득 값은 2-5 사이입니다. 하지만 몇몇 중간 소득들은 6을 넘습니다. 데이터 집합에 각 계층별 충분한 수의 인스턴스들을 갖는 것이 중요합니다. 그렇지 않으면 지층별 중요성에 대한 추정치가 편향될 수도 있습니다. 

다음 코드는 1.5로 나눈 소득 카테고리 속성을 만듭니다. 그리고 ceil을 사용해 반올림(이산 카테고리를 갖게 됩니다)합니다. 그 다음에 5보다 큰 모든 카테고리를 카테고리 5로 합칩니다.

>>> housing["income_cat"] = np.ceil(housing["median_income"] / 1.5)

>>> housing["income_cat"].where(housing["income_cat"] < 5, 5.0, inplace=True)

이제 소득 카테고리에 기반한 층화(stratified) 샘플링을 할 준비가 되었습니다. 사이킷런(Scikit-Learn)의 StratifiedShuffleSplit 클래스를 사용할 수 있습니다.

>>> from sklearn.model_selection import StratifiedShuffleSplit

>>> split = 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]

기대한대로 동작하는지 봅시다. 먼저 전체 housing 데이터셋에서 소득 카테고리 비중을 봅시다.

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

3.0    0.350581

2.0    0.318847

4.0    0.176308

5.0    0.114438

1.0    0.039826

name: income_cat, dtype: float64

위와 유사한 코드로 테스트 셋의 소득 카테고리 비중을 측정할 수 있습니다. 아래 표에서 전체 데이터셋과 층화(stratified) 샘플링으로 생성된 테스트 셋, 순수 랜덤 샘플링으로 생성된 테스트 셋의 소득 카테고리 비중을 비교할 수 있습니다. 층화(stratified) 샘플링으로 생성된 테스트 셋의 비중이 전체 데이터셋의 비중과 거의 동일한 것을 알 수 있습니다.

이제 데이터를 원래 상태로 되돌리기 위해 income_cat 속성을 제거해야 합니다.

>>> for set in (strat_train_set, strat_test_set):

set.drop(["income_cat"], axis=1, inplace=True)

테스트 셋을 생성하는 것에 대해서 알아보았습니다. 이 부분은 머신러닝 프로젝트에서 흔히 간과되지만 중요한 부분입니다. 게다가 이들 많은 아이디어들은 앞으로 교차 검증을 논의할 때 유용할 것입니다. 

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

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

머신러닝(Machine Learning) 기본 개념(Basci Concept)

머신러닝은 주어진 데이터를 훈련시켜(training), 훈련된 지식을 기반으로 새로운 입력(test input)에 대해 적절한 답(test output)을 찾고자 하는 일련의 과정이라고 말할 수 있습니다. 

이때 훈련시키는 데이터가 질문(training input)과 정답(training output)이 모두 주어진 경우가 있고, 질문만 주어진 경우가 있습니다. 전자의 경우를 라벨링(Labeling)이 되어 있다고 말합니다.

1. 지도학습(Supervised Learning)

훈련 데이터에 라벨링이 되어 있는 경우. 

즉, 각 질문(input)에 대해 무엇이 정답(output)인지 훈련데이터가 알고 있는 경우입니다. 

예를 들면 (2, 4) -> (8), (4, 3) -> (12), 이런 식으로 훈련데이터가 주어져 있다는 것입니다.

ex) regression - (x,y)글의 데이터를 가지고 모함수 y=f(x)의 관계를 예측하는 방법

Classification - 각 그룹별 특징을 학습하여 새로운 데이터가 어느 그룹에 속해야 하는지 판단하는 방법

2. 비지도학습(Unsupervised Learning)

데이터만 잔뜩 주어집니다. 

즉 문제는 있는데 답은 없습니다. 

우리가 할 수 있는 건, 문제 유형 정도를 구분할 수 있겠습니다. 

이를 clustering이라고 합니다.  

ex) clustering - 어떠한 데이터끼리 군집으로 묶을 수 있는지 판단하는 방법

Dimension reduction - 독립적인 특징(축)들을 추출해 이를 중심으로 데이터를 압축하는 저차원으로 압축하는 방법

★ 요즘 비지도학습에 PCA(Principle Component Analysis, 주성분 분석) 알고리즘을 적용하고 딥러닝(Deep Learning)+오토엔코더(Autoencoder)로 확대되면서 인공지능 분야를 가장 핫한 분야가 되게 하였습니다.  이 부분은 나중에 정리해 보도록 하겠습니다.

3. 강화학습(Reinforcement Learning)

미리 정답이 주어져 있진 않고, 시행마다 잘한 정도를 보상(reward)하여 줍니다(이는 동물들이 학습하는 방법과 유사).

ex) 엘레베이터 스케쥴링, 컴퓨터 체스, 복잡한 로봇의 제어 등등

4. 그 외 : 일부만 라벨링이 되어 있는 경우도 있고, 정보가 점진적으로(incremental) 주어지는 경우도 있고, 데이터가 너무 많은 경우, 적은 경우 등 다양한 기계학습 문제가 존재합니다.

아래 그림은 scikit-learn(파이썬에서 많이 사용하고 있는 머신러닝 라이브러리) 관련 사이트에서 머신러닝 알고리즘을 한 눈에 볼 수 있도록 맵으로 제시하고 있습니다. 

머신 러닝에 대한 전체 윤곽을 그려볼 수 있어서 앞으로 머신러닝을 배워나가는 길잡이로 알고 있으면 좋습니다. 

원본 맵 보기(http://scikit-learn.org/stable/tutorial/machine_learning_map/)

요즘 파이썬을 배워서 진출할 수 있는 직업 중에 데이터 사이언티스트가 핫한 것 같다. 4차 산업혁명과 함께 많이들 선호하고 있는 상태가 되었다.

하지만, 언론, 소셜 등에서 너무 많은 관심을 보이는 것이 거품이 될까 우려가 좀 된다. 2000년 초에 인터넷 기업 붐이 엄청나게 일어나고, 갑자기 거품이 꺼졌을 때 처럼 될 것 같아 보이기 때문이다. 

요즘 가장 열광하는 단어는 단연 AI일 것이라고 생각한다. 

그런데, 머신러닝(machine learning), 그 중에서 딥 러닝(deep learning)에 집중하는 것은 인터넷 자체가 혁신을 일으킬 것처럼 말했던 상황을 답습하는 것이 아닐까 하는 생각이 든다.

가장 중요한 것은 고객에게 제공하는 서비스, 제품일 것이다. 그래서 고객의 요구사항(애로사항)을 파악하는 것이 무엇보다 중요할 것이다. 

이런 관점을 갖고, 데이터와 AI의 결합을 바탕으로 고객들이 원하는 서비스(제품)을 만드는 기업 또는 사람이 되어야 한다고 믿는다.

'소프트웨어(데이터)가 모든 세계를 지배하는 세상'이라는 말은 디지털화된 데이터와 그것을 다루는 기술인 AI(그 중에서 머신 러닝)가 보편화된 세상을 말한다고 본다. 인터넷처럼 우리 생활에 스며들 것이기 때문에,  AI를 다루는 것과 데이터를 다루는 것은 기본이 될 것이다. 

앞으로 이것을 통해 어떤 가치를 고객에게 제공하느냐가 중요한 생존의 문제가 될 것이라는 것이다. 

사람들이 필요로 하는 가치(서비스, 제품)을 제공하는 수준까지 가기 위한 여정을 막 시작했다고 생각한다.

그럼, 가장 기본이 되는 라이브러리부터 알아보도록 하자.

데이터 사이언티스트들이 파이썬에서 사용하는 라이브러리들은 Numpy, Scipy, Pandas, Scikit-Learn 등이 있다. 

요즘에는 구글의 딥 러닝 라이브러리인 tensorflow의 인기가 높다.

tensorflow에 대해서는 따로 알아보도록 할 것이다.

1. Numpy, Scipy

Numpy와 Scipy는 숫자 및 과학 계산을 수행하기 위한 라이브러리라고 할 수 있다

Numpy는 기본 계산 기능을 가진 다차원 배열과 유용한 선형대수학 함수를 지원한다.

Scipy는 숫자 알고리즘 집합과 신호 처리, 최적화, 통계 등을 포함한 도메인에 특화된 기능을 지원한다.

(참고로, Matplotlib는 데이터 시각화를 위한 많은 툴을 가지고 있다)

2. Pandas

Pandas는 고성능의 데이터 구조와 데이터 분석 툴을 제공한다. 

Pandas의 주요 특징은 통합된 인덱싱과 함께 데이터 조작이 가능한 빠르고 효율적인 DataFrame 객체이다. 

DataFrame 구조는 매우 유연한 방법들로 작업이 가능한 스프레드시트처럼 볼 수 있다.

 재구조화하고, 행과 열을 추가하거나 제거하는 것을 통해 원하는 방식으로 어떤 데이타셋으로든 쉽게 변경할 수 있다. 

또한 데이터셋 간에 계산을 하고, 병합하고, 합류하는 고성능의 기능을 제공한다. 

또한, Pandas는 다른 형태의 포멧(CSV, EXCEL, SQL 데이터베이스, HDF5)으로부터 데이터를 가져오거나 내보낼 수 있는 툴을 가지고 있다. 

많은 경우, 이들 포멧들에 있는 데이터는 완벽하거나 전체적으로 구조화되어 있지 않을 것이다. 그런 경우, Pandas는 빠진 데이터를 핸들링하고 지능적으로 데이터를 정렬할 수 있도록 해준다. 

게다가, Pandas는 편리한 Matplotlib 인터페이스를 제공한다.

3. Scikit-learn

Scikit-learn은 Numpy, Scipy와 Matplotlib로 만들어진 머신 러닝 라이브러리이다.

Scikit-learn은 계층화, 회귀, 클러스터링, 차원 감소, 모델 선택과 전처리 같은 데이터 분석에 필요한 단순하고 효과적인 툴을 제공한다.

PS) 라이브러리별로 첨부한 정리 시트를 제공하는 원본 출처 및 원본 시트를 받고자 하시면 아래 링크를 보시기 바랍니다.

https://www.continuum.io/blog/developer-blog/learning-python-data-science-cheat-sheets

다음 편에는 Jupyter Notebook 환경에 대해 알아보도록 할 예정이다.

그럼 이만...