파이썬 2와 파이썬 3 중 무엇을 써야할까?

Python Packages in ML

확장성이란 무엇인가?

from sklearn.model_selection import cross_val_predict
from sklearn.metrics import confusion_matrix

y_train_pred = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3)
print(confusion_matrix(y_train_5, y_train_pred))

54,125개를 '5 아님'으로 정확하게 분류하였고(TN), 나머지 454개는 '5'라고 잘못 분류하였습니다(FP).
1,567개를 '5 아님'으로 잘못 분류하였고(FN), 나머지 3,854개를 정확히 '5'라고 분류하였습니다(TP). 

from sklearn.metrics import precision_score, recall_score

print(precision_score(y_train_5, y_train_pred))
print(recall_score(y_train_5, y_train_pred))

5로 판별된 이미지 중 74%만 정확합니다. 전체 숫자에서는 85%만 감지하였습니다.

정밀도와 재현율을 F₁ 점수라고 하는 하나의 숫자로 만들면 편리할 때가 많습니다. 특히 두 분류기를 비교할 때 유용합니다.
F₁ 점수는 정밀도와 재현율의 조화 평균(Harmonic Mean)입니다.

< Exp. 2. F₁ 점수 공식 >

F₁ 점수를 계산하기 위해서는 f1_score() 함수를 호출하면 됩니다.

Code

from sklearn.metrics import f1_score

print(f1_score(y_train_5, y_train_pred))

정밀도와 재현율이 비슷한 분류기에서는 F₁ 점수가 높습니다. 하지만 이게 항상 바람직한 것은 아닙니다. 상황에 따라 정밀도가 중요할 수도 있고 재현율이 중요할 수도 있습니다.
아쉽지만 정밀도와 재현율을 둘다 얻을 수는 없습니다. 정밀도를 올리면 재현율이 줄고 그 반대도 마찬가지 입니다. 이를 정밀도 / 재현율 트레이드오프라고 합니다.

from sklearn.datasets import fetch_mldata

X, y = mnist["data"], mnist["target"]
print(X.shape)
print(y.shape)

이미지가 70,000개가 있고 각 이미지에는 784개의 특성이 있습니다. 이미지가 28 × 28 픽셀이기 때문입니다.
개개의 특성은 단순히 0(흰색) 부터 255 (검은색) 까지의 픽셀 강도를 나타냅니다.

데이터셋에서 이미지 하나를 확인해보도록 하겠습니다. 샘플의 특성 벡터를 추출해서 28 × 28 배열로 크기를 바꾸고 맷플롯립의 imshow() 함수를 활용합니다.

Code

import matplotlib
import matplotlib.pyplot as plt

some_digit = X[36000]
some_digit_image = some_digit.reshape(28, 28)

plt.imshow(some_digit_image, cmap=matplotlib.cm.binary,
           interpolation="nearest")
plt.axis("off")
plt.show()

print(y[36000])

Output

>> 5.0

그림 상으로 숫자 '5' 처럼 보이는데, 실제 레이블을 확인해보니 5.0으로 나타납니다.

데이터를 분석하기 전 테스트 세트를 만들고 시작하도록 하겠습니다. MNIST 데이터셋의 경우 이미 훈련 세트(앞쪽 60,000개)와 테스트 세트(뒤쪽 10,000)로 나누어져 있습니다.

Code

import numpy as np

X_train, X_test, y_train, y_test = X[:60000], X[60000:], y[:60000], y[60000:]
shuffle_index = np.random.permutation(60000)
X_train, y_train = X_train[shuffle_index], y_train[shuffle_index]

훈련 세트를 섞어 모든 교차 검증 폴드가 비슷해지도록 만들었습니다. 특정 학습 알고리즘은 훈련 샘플의 순서에 민감하게 반응해서 많은 비슷한 샘플이 연이어 나타나면 성능이 나빠집니다. 데이터셋을 섞으면 이러한 문제를 방지할 수 있습니다.

2. 이진 데이터 훈련

Code

from sklearn.linear_model import SGDClassifier

from sklearn.linear_model import SGDClassifier
from sklearn.model_selection import StratifiedKFold

skfolds = StratifiedKFold(n_splits=3, random_state=42)

for train_index, test_index in skfolds.split(X_train, y_train_5):
    clone_clf = clone(sgd_clf)
    X_train_folds = X_train[train_index]
    y_train_folds = y_train_5[train_index]
    X_test_fold = X_train[test_index]
    y_test_fold = y_train_5[test_index]
    
    clone_clf.fit(X_train_folds, y_train_folds)
    y_pred = clone_clf.predict(X_test_fold)
    n_correct = sum(y_pred == y_test_fold)
    print(n_correct / len(y_pred))

사이킷런의 cross_val_score() 함수를 사용하여 폴드가 3개인 K-겹 교차 검증을 사용해 SGDClassifier 모델을 평가해보겠습니다. K-겹 교차 검증은 훈련 세트를 K개의 폴드로 나누고, 각 폴드에 대해 예측을 만들고 평가하기 위해 나머지 폴드로 훈련시킨 모델을 사용합니다.

Code

from sklearn.model_selection import cross_val_score

print(cross_val_score(sgd_clf, X_train, y_train_5, cv=3, scoring="accuracy"))

모든 교차 검증 폴드에 대해 정확도(Accuracy)가 95% 이상임을 확인할 수 있습니다.

from sklearn.base import BaseEstimator

class Never5Classifier(BaseEstimator):
    def fit(self, X, y=None):
        pass

    def predict(self, X):
        return np.zeros((len(X), 1), dtype=bool)


never_5_clf = Never5Classifier()
print(cross_val_score(never_5_clf, X_train, y_train_5, cv=3, scoring="accuracy"))

정확도가 90% 이상 나오는 것을 확인할 수 있습니다만, 숫자 '5'를 분류할 때보다 성능이 떨어지는 것을 확인할 수 있었습니다.
이 예제는 정확도를 분류기의 성능 지표로 선호하지 않는 이유를 보여줍니다. 특히 불균형한 데이터셋을 다룰 때 더욱 그렇습니다.

from sklearn.base import BaseEstimator, TransformerMixin

class DataFrameSelector(BaseEstimator, TransformerMixin):
    def __init__(self, attributes_names):
        self.attributes_names = attributes_names
    
    def fit(self, X, y = None):
        return self
    
    def transform(self, X):
        return X[self.attributes_names].values

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)),
    ('cat_encoder', CategoricalEncoder(encoding="onehot-dense"))
])

full_pipeline = FeatureUnion(transformer_list=[
    ("num_pipeline", num_pipeline),
    ("cat_pipeline", cat_pipeline),
])

housing_prepared = full_pipeline.fit_transform(housing)
print(housing_prepared)

housing = strat_train_set.drop("median_house_value", axis=1)
housing_labels = strat_train_set["median_house_value"].copy()

from sklearn.preprocessing import Imputer

imputer 객체에 중간값이 정상적으로 학습된 것을 확인할 수 있습니다.

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

위와 같은 표현 방식의 문제는 머신러닝 알고리즘이 가까이 있는 두 값이 떨어져 있는 두 값보다 더 비슷하다고 생각한다는 점입니다. 
이 문제는 일반적으로 카테고리별 이진 특성을 만들어 해결합니다. 한 특성만 1이고 나머지는 0이므로 이를 원-핫 인코딩(One-Hot Encoding)이라고 부릅니다.

사이킷런은 숫자로 된 범주형 값을 원-핫 벡터로 바꿔주는 OneHotEncoder를 제공합니다. 카테고리들을 원-핫 벡터로 인코딩 해보겠습니다. fit_transform() 함수는 2차원 배열을 넣어줘야 하는데 housing_cat_encoded는 1차원 배열이므로 구조를 바꿔주어야 합니다. 또한 출력 형태가 사이파이(Scipy) 희소 행렬입니다. 이는 수천 개의 카테고리가 있는 범주형 특성일 경우 매우 효율적입니다. 이런 특성을 원-핫 인코딩하면 열이 수천 개인 행렬로 변하고 각 행은 1이 하나뿐이고 그 외에는 모두 0으로 채워져 있을 것입니다. 0을 모두 메모리에 저장하는 것은 낭비이므로 희소 행렬은 0이 아닌 원소의 위치만 저장합니다. 이 행렬을 거의 일반적인 2차원 배열처럼 사용할 수 있지만 넘파이 배열로 바꾸려면 toarray() 함수를 호출하면 됩니다.

Code

from sklearn.preprocessing import OneHotEncoder

encoder = OneHotEncoder()
housing_cat_1hot = encoder.fit_transform(housing_cat_encoded.reshape(-1,1))
print(housing_cat_1hot.toarray())

Output

References

• 오렐리앙 제롱, '핸즈온 머신러닝', 한빛미디어, 2018

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

전체 20930개의 데이터가 16512개의 훈련 데이터, 4128개의 테스트 데이터로 나뉜 것을 확인할 수 있습니다.

from sklearn.model_selection import train_test_split

train_set, test_set = train_test_split(housing, test_size=0.2, random_state=42)
print(len(train_set), "train +", len(test_set), "test")

housing["income_cat"] = np.ceil(housing["median_income"] / 1.5)
housing["income_cat"].where(housing["income_cat"] < 5, 5.0, inplace=True)

housing["income_cat"].hist(bins=50, figsize=(20, 15))
plt.show()

소득 카테고리가 5개로 나뉜 히스토그램을 확인할 수 있습니다.

이제 소득 카테고리를 기반으로 계층 샘플링을 할 준비가 되었습니다. 사이킷런의 Stratified ShuffleSplit을 사용할 수 있습니다.

Code

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]

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

Output

전체 주택 데이터셋에서 소득 카테고리의 비율을 확인할 수 있습니다. 

비슷한 코드로 테스트 세트에 있는 소득 카테고리의 비율을 측정합니다. 아래의 그림 Fig. 1은 전체 데이터셋과 계층 샘플링으로 만든 테스트 세트에서 소득 카테고리 비율을 비교했습니다. 그림에서 보듯 계층 샘플링을 사용해 만든 테스트 세트가 전체 데이터셋에 있는 소득 카테고리의 비율과 거의 같습니다. 반면 일반 무작위 샘플링으로 만든 테스트 세트는 비율이 많이 달라졌습니다.

< Fig. 1. 계층 샘플링과 순수한 무작위 샘플링의 편향 비교 >

References

• 오렐리앙 제롱, '핸즈온 머신러닝', 한빛미디어, 2018

import os
import tarfile
from six.moves import urllib

DOWNLOAD_ROOT = "https://github.com/ageron/handson-ml/tree/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()

정상적으로 데이터가 적재되었음을 확인할 수 있습니다. 위의 표에서는 5개의 열만 보이지만 실제로는 10개의 열이 존재합니다.

4. 데이터 필드 시각화

Code

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

Output

출력된 히스토그램을 통해 여러 가지 정보들을 얻을 수 있고, 이로 인해 우리가 다룰 데이터를 많이 이해하게 되었습니다.

References

• 오렐리앙 제롱, '핸즈온 머신러닝', 한빛미디어, 2018

< Fig. 1. 머신러닝에서의 과대적합 예시 >

과대적합의 해결 방법은 아래와 같습니다.

모델을 단순하게 하고 과대적합의 위험을 감소시키기 위해 모델에 제약을 가하는 것을 규제(Regularization)라고 합니다. 예를 들어 앞서 만든 선형 모델은 두 개의 파라미터 𝜃₀와 𝜃₁을 가지고 있었습니다. 이는 데이터에 모델을 맞추기 위한 두 개의 자유도(Degree of Freedom)를 학습 알고리즘에 부여합니다. 모델은 직선의 절편(𝜃₀)과 기울기(𝜃₁)를 조절할 수 있습니다. 우리가 𝜃₁ = 0이 되도록 강제하면 알고리즘에 한 개의 자유도만 남게 되고, 데이터에 적절하게 맞춰지기 힘들어집니다. 즉, 할 수 있는 것이 훈련 데이터에 가능한 가깝게 되도록 직선을 올리거나 내리는 것이 전부이므로 결국 평균 근처가 됩니다. 알고리즘이 𝜃₁을 수정하도록 허락하되 작은 값을 갖도록 유지시키면 학습 알고리즘이 자유도 1과 2 사이의 적절한 어딘가에 위치할 것을 예상할 수 있습니다.

이러한 모델은 자유도가 2인 모델보다는 단순하고 자유도가 1인 모델보다는 복잡한 모델을 만들게 됩니다.
데이터에 완벽히 맞추는 것과 단순한 모델을 유지하는 것 사이의 올바른 균형을 찾는 것이 좋습니다.

2. 과소적합(Underfitting)

< Fig. 2. 과소적합, 과대적합의 예시 >

과소적합의 해결 방법은 아래와 같습니다.

데이터를 올바르게 학습시키기 위해서는 과대적합과 과소적합의 중간점을 찾는 것이 좋습니다.
Fig. 3에서 보이는 바와 같이 너무 잘 분류해도, 분류하지 못해도 올바른 모델이라고 할 수 없습니다.

< Fig. 3. 좋은 알고리즘과 나쁜 알고리즘의 예시 >

References

• 오렐리앙 제롱, '핸즈온 머신러닝', 한빛미디어, 2018
• https://medium.com/greyatom/what-is-underfitting-and-overfitting-in-machine-learning-and-how-to-deal-with-it-6803a989c76