
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split

# two_moon 데이터셋을 가지고 실습합니다.
X, y = make_moons(n_samples=200, noise=0.25, random_state=42)
Xm_train, Xm_test, ym_train, ym_test = train_test_split(X, y, stratify=y, random_state=42)

# two_moon 데이터를 시각화해봅니다.
plt.scatter(X[:, 0], X[:, 1], c=y)
plt.show()


# 랜덤 포레스트의 결정 경계를 시각화하는 함수입니다.
from matplotlib.colors import ListedColormap

def plot_decision_boundary(forest):
  figure = plt.figure(figsize=(36, 5))
  x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
  y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
  xx, yy = np.meshgrid(np.arange(x_min, x_max, .02), np.arange(y_min, y_max, .02))
  cm = plt.cm.RdBu
  cm_bright = ListedColormap(['#FF0000', '#0000FF'])

  for i in range(len(forest.estimators_)):
    ax = plt.subplot(1, 6, i+1)
    Z = forest.estimators_[i].predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1]
    Z = Z.reshape(xx.shape)
    ax.contourf(xx, yy, Z, cmap=cm, alpha=.8)
    ax.scatter(Xm_train[:, 0], Xm_train[:, 1], c=ym_train, cmap=cm_bright, edgecolors='k')
    ax.set_xticks(())
    ax.set_yticks(())

  ax = plt.subplot(1, 6, 6)
  Z = forest.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1]
  Z = Z.reshape(xx.shape)
  ax.contourf(xx, yy, Z, cmap=cm, alpha=.8)
  ax.scatter(Xm_train[:, 0], Xm_train[:, 1], c=ym_train, cmap=cm_bright, edgecolors='k')
  ax.set_xticks(())
  ax.set_yticks(())


from sklearn.ensemble import RandomForestClassifier

# 트리 5개로 구성된 랜덤 포레스트 모델을 만들어보겠습니다.
forest_m = RandomForestClassifier(n_estimators=5, random_state=2)
forest_m.fit(Xm_train, ym_train)

RandomForestClassifier(n_estimators=5, random_state=2)


# 주어진 함수를 사용하여 다섯개의 트리와 랜덤 포레스트의 결정 경계를 시각화해봅니다. 
plot_decision_boundary(forest_m)


from sklearn.datasets import load_breast_cancer

# 유방암 데이터를 로드하고 train/test셋으로 나눕니다.
cancer = load_breast_cancer()
Xc_train, Xc_test, yc_train, yc_test = train_test_split(cancer.data, cancer.target, random_state=42)


# 데이터에 어떤 특성이 있는지 살펴봅니다.
cancer.feature_names

array(['mean radius', 'mean texture', 'mean perimeter', 'mean area',
       'mean smoothness', 'mean compactness', 'mean concavity',
       'mean concave points', 'mean symmetry', 'mean fractal dimension',
       'radius error', 'texture error', 'perimeter error', 'area error',
       'smoothness error', 'compactness error', 'concavity error',
       'concave points error', 'symmetry error',
       'fractal dimension error', 'worst radius', 'worst texture',
       'worst perimeter', 'worst area', 'worst smoothness',
       'worst compactness', 'worst concavity', 'worst concave points',
       'worst symmetry', 'worst fractal dimension'], dtype='<U23')


# 랜덤 포레스트 분류기를 유방암 데이터에 훈련시킵니다. n_estimators=100, random_state=42
forest_c = RandomForestClassifier(n_estimators=100, random_state=42)
forest_c.fit(Xc_train, yc_train)

RandomForestClassifier(random_state=42)


print("Random Forest Training Set Accuracy: {:.3f}".format(forest_c.score(Xc_train, yc_train)))
print("Random Forest Test Set Accuracy: {:.3f}".format(forest_c.score(Xc_test, yc_test)))

Random Forest Training Set Accuracy: 1.000
Random Forest Test Set Accuracy: 0.965


def plot_imp(clf):
  sorted_idx = clf.feature_importances_.argsort()
  y_ticks = np.arange(0, len(cancer.feature_names))
  fig, ax = plt.subplots()
  ax.barh(y_ticks, clf.feature_importances_[sorted_idx])
  ax.set_yticklabels(cancer.feature_names[sorted_idx])
  ax.set_yticks(y_ticks)
  fig.tight_layout()
  plt.show()


from sklearn.tree import DecisionTreeClassifier

# 랜덤 포레스트와 비교하기 위해 결정트리 분류기를 생성하고 유방암 데이터에 훈련시킵니다.
dec_tree = DecisionTreeClassifier(random_state=42)
dec_tree.fit(Xc_train, yc_train)

DecisionTreeClassifier(random_state=42)


print("Decision Tree Training Set Accuracy: {:.3f}".format(dec_tree.score(Xc_train, yc_train)))
print("Decision Tree Test Set Accuracy: {:.3f}".format(dec_tree.score(Xc_test, yc_test)))

Decision Tree Training Set Accuracy: 1.000
Decision Tree Test Set Accuracy: 0.951


# 하나의 트리에서 제공하는 feature importance를 살펴보겠습니다.
dec_tree.feature_importances_

array([0.        , 0.02601101, 0.        , 0.        , 0.        ,
       0.        , 0.        , 0.69593688, 0.        , 0.        ,
       0.        , 0.        , 0.        , 0.01277192, 0.00155458,
       0.        , 0.00670697, 0.01702539, 0.        , 0.        ,
       0.0877369 , 0.10787925, 0.        , 0.03452044, 0.00985664,
       0.        , 0.        , 0.        , 0.        , 0.        ])


# 결정 트리의 특성 중요도를 시각화해봅니다.
plot_imp(dec_tree)


# 랜덤포레스트의 feature importance를 살펴봅니다.
forest_c.feature_importances_

array([0.03971058, 0.01460399, 0.05314639, 0.04277978, 0.00816485,
       0.01140166, 0.08321459, 0.0902992 , 0.00443533, 0.00443395,
       0.01951684, 0.00459978, 0.00868228, 0.04355077, 0.00464415,
       0.0036549 , 0.00701442, 0.00504716, 0.00371411, 0.00658253,
       0.08127686, 0.01649014, 0.07138828, 0.12319232, 0.01033481,
       0.01580059, 0.03174022, 0.17229521, 0.01310266, 0.00518165])


#  랜덤 포레스트의 feature importance를 시각화해봅니다.
plot_imp(forest_c)


from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import BaggingClassifier

# Bagging을 사용하여 cancer 데이터셋에 LogisticRegression 모델을 100개 훈련하여 앙상블해봅니다.
bagging = BaggingClassifier(LogisticRegression(), n_estimators=100, oob_score=True, n_jobs=-1, random_state=42)
bagging.fit(Xm_train, ym_train)

BaggingClassifier(base_estimator=LogisticRegression(), n_estimators=100,
                  n_jobs=-1, oob_score=True, random_state=42)


print("Train set accuracy: {:.3f}".format(bagging.score(Xm_train, ym_train)))
print("Test set accuracy: {:.3f}".format(bagging.score(Xm_test, ym_test)))

#  OOB 오차를 출력합니다.
print("OOB sample score: {:.3f}".format(bagging.oob_score_))

Train set accuracy: 0.813
Test set accuracy: 0.880
OOB sample score: 0.807


from sklearn.tree import DecisionTreeClassifier

#결정 트리로 배깅을 수행하는 것보다 랜덤 포레스트를 사용하는 것이 편리하지만 여기서는 직접 결정 트리에 배깅을 적용해보겠습니다.
bagging = BaggingClassifier(DecisionTreeClassifier(), n_estimators=5, n_jobs=-1, random_state=42)
bagging.fit(Xm_train, ym_train)

BaggingClassifier(base_estimator=DecisionTreeClassifier(), n_estimators=5,
                  n_jobs=-1, random_state=42)


# 랜덤 포레스트에서처럼 이 배깅 분류기에 있는 결정 트리의 결정 경계를 시각화해보겠습니다.
plot_decision_boundary(bagging)


# `n_estimators=100`으로 늘려서 cancer 데이터셋에 훈련시켜보고 훈련 세트의 테스트 세트 성능을 확인해보겠습니다.
bagging = BaggingClassifier(DecisionTreeClassifier(), n_estimators=100, oob_score=True, n_jobs=-1, random_state=42)
bagging.fit(Xm_train, ym_train)

BaggingClassifier(base_estimator=DecisionTreeClassifier(), n_estimators=100,
                  n_jobs=-1, oob_score=True, random_state=42)


print("Train set accuracy: {:.3f}".format(bagging.score(Xm_train, ym_train)))
print("Test set accuracy: {:.3f}".format(bagging.score(Xm_test, ym_test)))
print("OOB sample score: {:.3f}".format(bagging.oob_score_))

Train set accuracy: 1.000
Test set accuracy: 0.900
OOB sample score: 0.900


from sklearn.ensemble import AdaBoostClassifier

# AdaBoost를 two_moons 데이터에 적용해봅니다.
ada = AdaBoostClassifier(n_estimators=5, random_state=42)
ada.fit(Xm_train, ym_train)

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-1-d7b7492dffe3> in <module>
      3 # AdaBoost를 two_moons 데이터에 적용해봅니다.
      4 ada = AdaBoostClassifier(n_estimators=5, random_state=42)
----> 5 ada.fit(Xm_train, ym_train)

NameError: name 'Xm_train' is not defined


# AdaBoost의 각 estimator의 결정 경계를 시각화해봅니다.
plot_decision_boundary(ada)


# 이번에는 AdaBoost를 breast cancer 데이터에 적용해봅니다.
ada = AdaBoostClassifier(n_estimators=100, random_state=42)
ada.fit(Xc_train, yc_train)

AdaBoostClassifier(n_estimators=100, random_state=42)


print("Train set accuracy: {:.3f}".format(ada.score(Xc_train, yc_train)))
print("Test set accuracy: {:.3f}".format(ada.score(Xc_test, yc_test)))

Train set accuracy: 1.000
Test set accuracy: 0.944


# AdaBoost의 특성 중요도를 시각화해봅니다.
plot_imp(ada)


from sklearn.datasets import load_breast_cancer
from sklearn.feature_selection import SelectPercentile, f_classif
from sklearn.model_selection import train_test_split

cancer = load_breast_cancer()

# 고정된 난수를 발생시킵니다.
rng = np.random.RandomState(42)
noise = rng.normal(size=(len(cancer.data), 50))
# 데이터에 노이즈 특성을 추가합니다. 처음 30개는 원본 특성이고 다음 50개는 노이즈입니다.
X_w_noise = np.hstack([cancer.data, noise])


# 원 데이터와 노이즈가 추가된 데이터의 크기를 비교해봅니다.
print(cancer.data.shape)
print(X_w_noise.shape)

(569, 30)
(569, 80)


# 데이터를 train/test셋으로 나눕니다. random_state=42, test_size=0.5
X_train, X_test, y_train, y_test = train_test_split(X_w_noise, cancer.target, random_state=42, test_size=0.5)


# f_classif(기본값)과 SelectPercentile을 사용하여 특성의 50%를 선택합니다.
select = SelectPercentile(score_func=f_classif, percentile=50)
select.fit(X_train, y_train)

# 훈련 세트에 적용합니다.
X_train_selected = select.transform(X_train)


print("X_train.shape", X_train.shape)
print("X_train_selected.shape", X_train_selected.shape)

X_train.shape (284, 80)
X_train_selected.shape (284, 40)


# `get_support` 메서드는 선택된 특성을 boolean 값으로 표시해줍니다. 어떤 특성이 선택되었는지 확인해봅니다.
mask = select.get_support()
print(mask)

[ True  True  True  True  True  True  True  True  True  True  True False
  True  True False  True  True  True False False  True  True  True  True
  True  True  True  True  True  True False False False  True False  True
 False False False False False False False  True False False False  True
 False False False False False False  True False False False  True False
 False False  True False False False  True  True  True False False False
  True  True False False False False  True  True]


# 위 마스크를 시각화해봅니다.
plt.matshow(mask.reshape(1, -1), cmap='gray_r')
plt.xlabel("feature number")
plt.yticks([0])

([<matplotlib.axis.YTick at 0x7f0abe733590>],
 <a list of 1 Text major ticklabel objects>)


from sklearn.linear_model import LogisticRegression

# 테스트 데이터 변환
X_test_selected = select.transform(X_test)

# LogisticRegression모델을 생성하고 원본 데이터에 훈련시킨 성능과 중요한 특성들이 선택된 데이터에 훈련시킨 성능을 비교해봅니다.
lr = LogisticRegression(max_iter=10000)
lr.fit(X_train, y_train)
print("전체 특성을 사용한 정확도", lr.score(X_test, y_test))
lr.fit(X_train_selected, y_train)
print("선택된 일부 특성을 사용한 정확도", lr.score(X_test_selected, y_test))

전체 특성을 사용한 정확도 0.9614035087719298
선택된 일부 특성을 사용한 정확도 0.9649122807017544


from sklearn.datasets import load_iris

iris_X, iris_y = load_iris(return_X_y=True)
iris_X.shape

(150, 4)


from sklearn.feature_selection import SelectKBest, chi2

# SelectKBest와 chi2 테스트를 사용하여 iris data에서 두개의 가장 중요한 특성을 선택합니다.
X_new = SelectKBest(chi2, k=2).fit_transform(iris_X, iris_y)
print(X_new.shape)

(150, 2)


from sklearn.feature_selection import SelectFromModel
from sklearn.ensemble import RandomForestClassifier

# RandomForestClassifier와 SelectFromModel을 이용하여 중요한 특성을 선택합니다.
select = SelectFromModel(RandomForestClassifier(n_estimators=100, random_state=42), threshold='median')


# 모델을 데이터에 훈련시키고 선택된 특성의 shape을 출력합니다.
select.fit(X_train, y_train)
X_train_l1 = select.transform(X_train)
print("X_train.shape:", X_train.shape)
print("X_train_l1.shape:", X_train_l1.shape)

X_train.shape: (284, 80)
X_train_l1.shape: (284, 40)


# 선택된 특성을 같은 방식으로 그려보겠습니다.
mask = select.get_support()
plt.matshow(mask.reshape(1, -1), cmap='gray_r')
plt.xlabel("featue number")

Text(0.5, 0, 'featue number')


# LogisticRegression 모델로 성능이 얼마나 향상되었는지 확인해봅니다.
X_test_l1 = select.transform(X_test)
score = LogisticRegression(max_iter=10000).fit(X_train_l1, y_train).score(X_test_l1, y_test)
print("test score", score)

test score 0.9543859649122807


from sklearn.feature_selection import RFE

# RFE를 생성하고 데이터에 훈련시킵니다.
select = RFE(RandomForestClassifier(n_estimators=100, random_state=42), n_features_to_select=40)
select.fit(X_train, y_train)


# 선택된 특성을 시각화합니다.
mask = select.get_support()
plt.matshow(mask.reshape(1, -1), cmap='gray_r')
plt.xlabel("feature number")


# RFE를 사용해서 특성을 선택했을 때 로지스틱 회귀의 정확도를 확인해보겠습니다.
X_train_rfe = select.transform(X_train)
X_test_rfe = select.transform(X_test)

score = LogisticRegression(max_iter=10000).fit(X_train_rfe, y_train).score(X_test_rfe, y_test)
print("test score", score)


# 또한 RFE에 사용된 모델을 이용해서도 예측을 할 수 있습니다. 이 경우 선택된 특성만 사용됩니다.
score = select.score(X_test, y_test)
print(score)

Random Forest¶

1-1. Random Forest: Bagging (=Bootstrap Aggregation)¶

1-2. Random Forest: Feature Randomness¶

1-3. Scikit-learn Random Forest¶

2. Ensemble Methods: Bagging and Boosting¶

2-1. Bagging (=Bootstrap Aggregation)¶

2-1-1. Out-of-Bag error (OOB)¶

2-2. Boosting¶

2-2-1. Bagging vs Boosting¶

3. Feature Selection¶

3-1. 일변량 통계¶

3-1-1. Selecting K best features¶

3.2 모델 기반 특성 선택¶

3.3 반복적 특성 선택¶

TAEWON KIM

Recent posts

Comments

Random Forest¶

1-1. Random Forest: Bagging (=Bootstrap Aggregation)¶

1-2. Random Forest: Feature Randomness¶

1-3. Scikit-learn Random Forest¶

2. Ensemble Methods: Bagging and Boosting¶

2-1. Bagging (=Bootstrap Aggregation)¶

2-1-1. Out-of-Bag error (OOB)¶

2-2. Boosting¶

2-2-1. Bagging vs Boosting¶

3. Feature Selection¶

3-1. 일변량 통계¶

3-1-1. Selecting K best features¶

3.2 모델 기반 특성 선택¶

3.3 반복적 특성 선택¶

TAEWON KIM

Recent posts

Newsletter

Comments