Feature Selection

이수진·2023년 12월 1일
유저 로그 분석데이터 분석
0

Feature selection은 모델의 성능을 향상시키고 모델의 복잡도를 줄이기 위해 중요한 특성만을 선택하는 과정이다.

Feature selection에는 여러가지 알고리즘이 있다.

상관관계 기반 선택

목표 변수와 각 특성 간의 상관관계를 계산하여 중요 특성을 선택한다. 특성간 다중공선성을 고려해 상관성 높은 특성중 하나를 선택한다.
상관계수가 높을수록 두 변수 간의 선형적인 관계가 강하다고 판단한다. 

import pandas as pd
import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# 가상의 데이터셋을 사용 (iris 데이터셋)
iris = load_iris()
X = iris.data
y = iris.target

# 데이터프레임 생성
df = pd.DataFrame(X, columns=iris.feature_names)
df['target'] = y

# 상관계수 계산
correlation_matrix = df.corr()

# 목표 변수와의 상관계수 확인 (여기에서는 간단하게 마지막 열을 목표 변수로 설정)
target_correlation = correlation_matrix['target']

# 상관계수의 절댓값이 높은 특성 선택 (예: 0.2 이상)
selected_features = target_correlation[abs(target_correlation) > 0.2].index

# 선택된 특성 확인
print("Selected Features:", selected_features)

절댓값이 0.2보다 큰 상관계수를 가진 특성을 선택하는 예시이다.

일반적으로

0.0 ~ 0.19: 거의 무시됨
0.20 ~ 0.39: 매우 약한 상관관계
0.40 ~ 0.59: 약한 상관관계
0.60 ~ 0.79: 중간 정도의 상관관계
0.80 ~ 1.0: 강한 상관관계
특정 문제나 데이터에 따라 적합한 임계값이 다를 수 있다.

Filter Methods (필터 방법):

Filter Methods에서는 특성과 타겟 간의 통계적인 관계를 기반으로 특성을 선택한다. 주로 분산이 낮거나 높은 특성, 상관관계가 낮은 특성 등을 제거하여 모델의 복잡도를 줄이는 데 기여한다.

분산 기준 (Variance Threshold):

분산이 낮은 특성은 정보를 거의 제공하지 않을 가능성이 높다. 따라서 분산이 낮은 특성을 제거하여 모델의 복잡도를 줄일 수 있다.

import pandas as pd
from sklearn.feature_selection import VarianceThreshold
from sklearn.datasets import load_iris

# 가상의 데이터셋을 사용 (iris 데이터셋)
iris = load_iris()
X = iris.data
y = iris.target

# 데이터프레임 생성
df = pd.DataFrame(X, columns=iris.feature_names)
df['target'] = y

# 분산 기준을 사용하여 특성 선택
threshold = 0.2  # 분산이 이 값보다 낮은 특성을 제거
selector = VarianceThreshold(threshold=threshold)
X_selected = selector.fit_transform(X)

# 선택된 특성 확인
selected_features = df.columns[selector.get_support()]
print("Selected Features:", selected_features)

# 선택된 특성을 포함한 데이터프레임 생성
df_selected = pd.DataFrame(X_selected, columns=selected_features)
df_selected['target'] = y

# 선택된 특성을 포함한 데이터프레임 출력
print("\nDataFrame with Selected Features:")
print(df_selected.head())

상관관계 기준 (Correlation Threshold):

특성 간의 상관관계가 높은 경우, 중복된 정보를 포함할 가능성이 높다. 특성 간의 상관관계가 높은 경우 하나의 특성만을 선택하여 다중공선성을 감소시킬 수 있다.

import pandas as pd
from sklearn.datasets import load_iris
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import f_classif

# 가상의 데이터셋을 사용 (iris 데이터셋)
iris = load_iris()
X = iris.data
y = iris.target

# 데이터프레임 생성
df = pd.DataFrame(X, columns=iris.feature_names)
df['target'] = y

# 상관관계 기준을 사용하여 특성 선택
num_features_to_select = 2  # 선택할 특성의 수
selector = SelectKBest(score_func=f_classif, k=num_features_to_select)
X_selected = selector.fit_transform(X, y)

# 선택된 특성 확인
selected_features = df.columns[selector.get_support()]
print("Selected Features:", selected_features)

# 선택된 특성을 포함한 데이터프레임 생성
df_selected = pd.DataFrame(X_selected, columns=selected_features)
df_selected['target'] = y

# 선택된 특성을 포함한 데이터프레임 출력
print("\nDataFrame with Selected Features:")
print(df_selected.head())

카이제곱 검정 (Chi-Square Test):

범주형 변수와 이산형 타겟 간의 독립성을 검정하여 특성을 선택한다. 이는 범주형 데이터에서 유용하게 활용된다.

import pandas as pd
from sklearn.datasets import load_iris
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2

# 가상의 데이터셋을 사용 (iris 데이터셋)
iris = load_iris()
X = iris.data
y = iris.target

# 데이터프레임 생성
df = pd.DataFrame(X, columns=iris.feature_names)
df['target'] = y

# 카이제곱검정을 사용하여 특성 선택
num_features_to_select = 2  # 선택할 특성의 수
selector = SelectKBest(score_func=chi2, k=num_features_to_select)
X_selected = selector.fit_transform(X, y)

# 선택된 특성 확인
selected_features = df.columns[selector.get_support()]
print("Selected Features:", selected_features)

# 선택된 특성을 포함한 데이터프레임 생성
df_selected = pd.DataFrame(X_selected, columns=selected_features)
df_selected['target'] = y

# 선택된 특성을 포함한 데이터프레임 출력
print("\nDataFrame with Selected Features:")
print(df_selected.head())

상호정보량 (Mutual Information):

특성과 타겟 간의 상호 정보량을 측정하여 중요한 특성을 선택한다. 상호 정보량은 두 변수 간의 의존성을 측정하는 지표로 사용된다.

import pandas as pd
from sklearn.datasets import load_iris
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import mutual_info_classif

# 가상의 데이터셋을 사용 (iris 데이터셋)
iris = load_iris()
X = iris.data
y = iris.target

# 데이터프레임 생성
df = pd.DataFrame(X, columns=iris.feature_names)
df['target'] = y

# 상호정보량을 사용하여 특성 선택
num_features_to_select = 2  # 선택할 특성의 수
selector = SelectKBest(score_func=mutual_info_classif, k=num_features_to_select)
X_selected = selector.fit_transform(X, y)

# 선택된 특성 확인
selected_features = df.columns[selector.get_support()]
print("Selected Features:", selected_features)

# 선택된 특성을 포함한 데이터프레임 생성
df_selected = pd.DataFrame(X_selected, columns=selected_features)
df_selected['target'] = y

# 선택된 특성을 포함한 데이터프레임 출력
print("\nDataFrame with Selected Features:")
print(df_selected.head())

score_func 매개변수에는 사용할 통계적 검정 방법을 설정하며, 여기서는 상호정보량에 적합한 mutual_info_classif를 사용

일원분산분석 (ANOVA):

수치형 특성과 범주형 타겟 간의 분산 차이를 검정하여 유의미한 특성을 선택한다. 주로 회귀와 분류 문제에서 사용된다.

import pandas as pd
from sklearn.datasets import load_iris
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import f_classif

# 가상의 데이터셋을 사용 (iris 데이터셋)
iris = load_iris()
X = iris.data
y = iris.target

# 데이터프레임 생성
df = pd.DataFrame(X, columns=iris.feature_names)
df['target'] = y

# ANOVA를 사용하여 특성 선택
num_features_to_select = 2  # 선택할 특성의 수
selector = SelectKBest(score_func=f_classif, k=num_features_to_select)
X_selected = selector.fit_transform(X, y)

# 선택된 특성 확인
selected_features = df.columns[selector.get_support()]
print("Selected Features:", selected_features)

# 선택된 특성을 포함한 데이터프레임 생성
df_selected = pd.DataFrame(X_selected, columns=selected_features)
df_selected['target'] = y

# 선택된 특성을 포함한 데이터프레임 출력
print("\nDataFrame with Selected Features:")
print(df_selected.head())

score_func 매개변수에는 사용할 통계적 검정 방법을 설정하며, 여기서는 분류 문제에 적합한 f_classif를 사용

통계적 검정 방법:

다양한 통계적 검정 방법을 활용하여 특성과 타겟 간의 유의미한 차이를 검정하고 선택하는 방법이다. t-검정, F-검정 등이 여기에 속한다.

import pandas as pd
from sklearn.datasets import load_iris
from sklearn.feature_selection import SelectKBest
from scipy.stats import ttest_ind

# 가상의 데이터셋을 사용 (iris 데이터셋)
iris = load_iris()
X = iris.data
y = iris.target

# 데이터프레임 생성
df = pd.DataFrame(X, columns=iris.feature_names)
df['target'] = y

# t-검정을 사용하여 특성 선택
num_features_to_select = 2  # 선택할 특성의 수
selected_features = []

for column in df.columns[:-1]:  # 마지막 열은 타겟 변수이므로 제외
    t_stat, p_value = ttest_ind(df[df['target'] == 0][column], df[df['target'] == 1][column])
    # 여기에서는 두 클래스 간의 t-검정을 수행했습니다. 실제로는 데이터의 클래스 수와 특성에 따라 다르게 조정해야 합니다.

    if p_value < 0.05:  # 유의수준 0.05를 기준으로 선택
        selected_features.append(column)

# 선택된 특성 출력
print("Selected Features:", selected_features)

# 선택된 특성을 포함한 데이터프레임 생성
df_selected = df[selected_features + ['target']]

# 선택된 특성을 포함한 데이터프레임 출력
print("\nDataFrame with Selected Features:")
print(df_selected.head())

t-검정을 기준으로 특성을 선택하는 방법
해당 특성의 두 클래스 간의 t-검정을 수행한 후, 유의수준을 기준으로 선택 여부를 결정

Wrapper Methods (래퍼 방법):

Wrapper Methods는 모델의 성능을 기반으로 특성을 선택한다. 주로 전방 선택법(Forward Selection), 후방 제거법(Backward Elimination), 순차적 특성 선택법(Sequential Feature Selection) 등이 사용되며, 이들 방법은 반복적으로 모델을 학습하여 특성을 선택한다.

전방 선택법 (Forward Selection)

: 특성을 하나씩 추가하면서 모델의 성능을 평가하고 최적의 특성 조합을 찾는 방법

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

# 가상의 데이터셋을 사용 (iris 데이터셋)
iris = load_iris()
X = iris.data
y = iris.target

# 데이터를 훈련 세트와 테스트 세트로 나눔
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 전방 선택법을 사용하여 특성 선택
selected_features = []
best_accuracy = 0.0
remaining_features = list(range(X.shape[1]))

while remaining_features:
    best_feature = None
    for feature in remaining_features:
        # 현재까지 선택된 특성에 현재 특성을 추가
        candidate_features = selected_features + [feature]

        # 모델 학습 및 성능 평가
        model = RandomForestClassifier(random_state=42)
        model.fit(X_train.iloc[:, candidate_features], y_train)
        y_pred = model.predict(X_test.iloc[:, candidate_features])
        accuracy = accuracy_score(y_test, y_pred)

        # 최고 정확도를 갖는 특성 업데이트
        if accuracy > best_accuracy:
            best_accuracy = accuracy
            best_feature = feature

    # 선택된 특성에 추가하고 후보 목록에서 제거
    selected_features.append(best_feature)
    remaining_features.remove(best_feature)

# 선택된 특성 출력
print("Selected Features:", selected_features)

해당 코드에서는 랜덤 포레스트 분류기를 이용하여 각 단계에서 특성을 선택하고 모델의 성능을 평가한다. 최고의 정확도를 갖는 특성을 선택하며, 이를 반복하여 최적의 특성 조합을 찾는다.

후방 제거법 (Backward Elimination)

: 모든 특성을 포함한 모델에서 시작하여 가장 덜 유용한 특성을 하나씩 제거하면서 모델의 성능을 평가

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

# 가상의 데이터셋을 사용 (iris 데이터셋)
iris = load_iris()
X = iris.data
y = iris.target

# 데이터를 훈련 세트와 테스트 세트로 나눔
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 후방 제거법을 사용하여 특성 선택
selected_features = list(range(X.shape[1]))

while len(selected_features) > 1:
    worst_feature = None
    for feature in selected_features:
        # 현재까지 선택된 특성에서 현재 특성을 제외
        candidate_features = [f for f in selected_features if f != feature]

        # 모델 학습 및 성능 평가
        model = RandomForestClassifier(random_state=42)
        model.fit(X_train[:, candidate_features], y_train)
        y_pred = model.predict(X_test[:, candidate_features])
        accuracy = accuracy_score(y_test, y_pred)

        # 현재까지 최저 정확도를 갖는 특성 업데이트
        if worst_feature is None or accuracy < worst_accuracy:
            worst_accuracy = accuracy
            worst_feature = feature

    # 선택된 특성에서 최저 정확도를 갖는 특성을 제외
    selected_features.remove(worst_feature)

# 선택된 특성 출력
print("Selected Features:", selected_features)

랜덤 포레스트 분류기를 이용하여 각 단계에서 특성을 제외하면서 모델의 성능을 평가한다. 최저 정확도를 갖는 특성을 제외하면서 최적의 특성 조합을 찾는다.

순차적 특성 선택법 (Sequential Feature Selection)

: 전방선택법(Forward Selection)이나 후방제거법(Backward Elimination)과 유사하지만, 각 단계에서 특성을 추가하거나 제거할 때 모델의 성능이 가장 크게 향상되는 특성을 선택한다. mlxtend 라이브러리를 사용한다. 

pip install mlxtend

import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
from mlxtend.feature_selection import SequentialFeatureSelector

# 가상의 데이터셋을 사용 (iris 데이터셋)
iris = load_iris()
X = iris.data
y = iris.target

# 데이터를 훈련 세트와 테스트 세트로 나눔
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 랜덤 포레스트 분류기를 사용한 순차적 특성 선택법
model = RandomForestClassifier(random_state=42)
sfs = SequentialFeatureSelector(model,
                                k_features='best',  # 선택할 특성의 개수 (여기서는 최적의 개수를 선택)
                                forward=True,  # True면 전방선택법, False면 후방제거법
                                floating=False,
                                scoring='accuracy',  # 성능 평가 지표
                                cv=5)  # 교차 검증의 폴드 수

sfs.fit(X_train, y_train)

# 선택된 특성 출력
selected_features = list(sfs.k_feature_idx_)
print("Selected Features:", selected_features)

# 선택된 특성을 포함한 데이터프레임 생성
df_selected = pd.DataFrame(X_train[:, selected_features], columns=[f'feature_{i}' for i in selected_features])
df_selected['target'] = y_train

# 선택된 특성을 포함한 데이터프레임 출력
print("\nDataFrame with Selected Features:")
print(df_selected.head())

SequentialFeatureSelector를 사용하여 랜덤 포레스트 분류기를 이용한 순차적 특성 선택법을 구현한다. 최적의 특성 개수를 선택하도록 설정하고, 전방선택법을 사용하고 있다.

Embedded Methods (내장 방법):

Embedded Methods에서는 모델 학습 과정에서 특성 선택이 이루어진다. 일부 모델은 학습 중에 특성의 중요도를 평가하고, 중요하지 않은 특성을 제외하도록 설계되어 있다. 예를 들어, LASSO(L1 정규화)와 같은 방법이 해당된다.

PCA (Principal Component Analysis):

PCA는 데이터의 차원을 축소하고 주성분을 선택하여 새로운 특성 공간으로 매핑하는 방법이다. 주로 차원 축소를 목적으로 사용되지만, 중요한 특성만을 선택함으로써 모델의 복잡도를 줄이는 역할도 한다.

import pandas as pd
from sklearn.datasets import load_iris
from sklearn.decomposition import PCA
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score

# 가상의 데이터셋을 사용 (iris 데이터셋)
iris = load_iris()
X = iris.data
y = iris.target

# 데이터프레임 생성
df = pd.DataFrame(X, columns=iris.feature_names)
df['target'] = y

# 훈련 세트와 테스트 세트로 나눔
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# PCA를 사용하여 특성 선택
n_components = 2  # 선택할 주성분의 개수
pca = PCA(n_components=n_components)
X_train_pca = pca.fit_transform(X_train)
X_test_pca = pca.transform(X_test)

# 주성분 선택 결과 출력
print(f"Selected Principal Components: {pca.components_}")

# 선택된 주성분으로 랜덤 포레스트 모델 학습
model = RandomForestClassifier(random_state=42)
model.fit(X_train_pca, y_train)

# 테스트 세트로 모델 평가
y_pred = model.predict(X_test_pca)
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy with PCA-selected features: {accuracy}")

Tree-based Methods:

Tree-based methods를 사용한 특성 선택은 주로 특성의 중요도(Feature Importance)를 기반으로 이루어진다. Tree-based methods에서 각 특성의 중요도를 평가할 수 있기 때문에, 중요한 특성들을 선택하여 모델을 훈련시키는 방법을 말한다.

여러 트리 기반의 알고리즘에서 특성의 중요도는 각 트리에서 분할 기준을 선택할 때 해당 특성이 얼마나 영향을 미치는지를 나타낸다. 중요도는 주로 불순도(impurity) 감소나 정보 이득(information gain)과 관련된 지표로 측정된다.

가장 대표적인 트리 기반 알고리즘은 랜덤 포레스트(Random Forest)와 Gradient Boosting 계열이다.

랜덤포레스트 (random forest)

  • 랜덤 포레스트는 여러 결정 트리를 앙상블하여 생성된다.
  • 각 트리는 부트스트랩 샘플링을 통해 생성되고, 각 노드에서 최적의 분할 기준을 찾을 때 무작위로 선택된 특성 부분 집합을 고려한다.
  • 각 트리에서 특성의 중요도를 측정하고, 이를 기반으로 전체 랜덤 포레스트의 특성 중요도를 평균하여 얻을 수 있다.
  • 중요도가 낮은 특성은 제외할 수 있다.
  • 해당 모델에서 제공하는 특성 중요도를 활용하여 진행된다. 
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
import numpy as np

# 가상의 데이터셋을 사용 (iris 데이터셋)
iris = load_iris()
X = iris.data
y = iris.target

# 데이터를 훈련 세트와 테스트 세트로 나눔
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 랜덤 포레스트 모델 생성 및 학습
rf_model = RandomForestClassifier(random_state=42)
rf_model.fit(X_train, y_train)

# 특성 중요도 확인
feature_importances = rf_model.feature_importances_
print("Feature Importances:", feature_importances)

# 중요도가 높은 순서대로 특성의 인덱스를 정렬
sorted_feature_indices = np.argsort(feature_importances)[::-1]

# 상위 k개의 특성 선택 (예: 상위 2개의 특성 선택)
top_k = 2
selected_features = sorted_feature_indices[:top_k]
print(f"Selected Features (Top {top_k}):", selected_features)

featureimportances 속성을 통해 각 특성의 중요도를 확인하고, 중요도가 높은 순서대로 특성의 인덱스를 정렬하여 상위 k개의 특성을 선택한다.

Gradient Boosting 계열 (XGBoost, LightGBM)

  • Gradient Boosting 계열 역시 각 트리가 순차적으로 생성되며, 이전 트리의 예측 오차를 보완하는 방식으로 동작한다.
  • 각 트리에서의 특성 중요도를 측정하고, 중요도가 낮은 특성은 제외할 수 있다.
  • XGBoost
from sklearn.datasets import load_iris
from xgboost import XGBClassifier
from sklearn.model_selection import train_test_split
import numpy as np

# 가상의 데이터셋을 사용 (iris 데이터셋)
iris = load_iris()
X = iris.data
y = iris.target

# 데이터를 훈련 세트와 테스트 세트로 나눔
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# XGBoost 모델 생성 및 학습
xgb_model = XGBClassifier(random_state=42)
xgb_model.fit(X_train, y_train)

# 특성 중요도 확인
feature_importances = xgb_model.feature_importances_
print("Feature Importances:", feature_importances)

# 중요도가 높은 순서대로 특성의 인덱스를 정렬
sorted_feature_indices = np.argsort(feature_importances)[::-1]

# 상위 k개의 특성 선택 (예: 상위 2개의 특성 선택)
top_k = 2
selected_features = sorted_feature_indices[:top_k]
print(f"Selected Features (Top {top_k}):", selected_features)

featureimportances 속성을 통해 각 특성의 중요도를 확인하고, 중요도가 높은 순서대로 특성의 인덱스를 정렬하여 상위 k개의 특성을 선택한다.

  • LightGBM

# LightGBM 모델 생성
params = {'objective': 'binary', 'metric': 'binary_logloss', 'boosting_type': 'gbdt'}
train_data = lgb.Dataset(X_train, label=y_train)
model = lgb.train(params, train_data, num_boost_round=100)

# 특성 중요도 시각화
lgb.plot_importance(model, figsize=(10, 6), title='Feature Importance')

# 중요도가 낮은 특성 제거
threshold = 50  # 예를 들어, 중요도 상위 50개의 특성만 선택
selected_features = [feature for i, feature in enumerate(X_train.columns) if i in model.feature_importance().argsort()[-threshold:]]
X_train_selected = X_train[selected_features]
X_test_selected = X_test[selected_features]

# 새로운 모델 생성 및 평가
train_data_selected = lgb.Dataset(X_train_selected, label=y_train)
model_selected = lgb.train(params, train_data_selected, num_boost_round=100)
y_pred = model_selected.predict(X_test_selected)
y_pred_binary = (y_pred > 0.5).astype(int)
accuracy = accuracy_score(y_test, y_pred_binary)

print(f"Accuracy with selected features: {accuracy}")

피처 중요도 확인

  • 각 트리 기반 알고리즘에서 피처 중요도는 모델의 featureimportances 속성을 통해 확인할 수 있습니다.
  • 중요도가 높은 특성은 해당 모델에서 예측에 큰 영향을 미치는 특성으로 간주됩니다.

특성 선택 방법

  • 특성 중요도를 기반으로 한 특성 선택은 일정 임계값 이상의 중요도를 가진 특성을 선택하는 방식이 일반적입니다.
  • 사용자가 지정한 임계값 이하의 중요도를 가진 특성들을 제거하여 모델을 구성할 수 있습니다.

Regularization (정규화):

일부 선형 모델은 L1 또는 L2 정규화를 통해 특성의 가중치를 조절한다. 주로 선형회귀 모델에 많이 사용된다. 모델의 복잡도를 제어해 가중치를 축소하는 방법으로 Ridge 와 Lasso방법이 있다. L1 정규화(LASSO)는 일부 특성의 가중치를 0으로 만들어 특성 선택 효과를 낸다.

Lasso 회귀를 사용한 방법은 다음과 같다. 

from sklearn.datasets import load_iris
from sklearn.linear_model import Lasso
from sklearn.model_selection import train_test_split
import numpy as np

# 가상의 데이터셋을 사용 (iris 데이터셋)
iris = load_iris()
X = iris.data
y = iris.target

# 데이터를 훈련 세트와 테스트 세트로 나눔
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 라쏘 회귀 모델 생성 및 학습
alpha = 0.1  # 정규화 강도를 조절하는 매개변수 (0.1은 예시로 조절 필요)
lasso_model = Lasso(alpha=alpha, random_state=42)
lasso_model.fit(X_train, y_train)

# 특성의 가중치 확인
feature_weights = lasso_model.coef_
print("Feature Weights:", feature_weights)

# 가중치가 0이 아닌 특성 선택
selected_features = np.where(feature_weights != 0)[0]
print("Selected Features:", selected_features)

coef_ 속성을 통해 특성의 가중치를 확인하고, 가중치가 0이 아닌 특성을 선택한다. 라쏘 회귀는 L1 정규화를 사용하며, 가중치가 0이 되는 특성이 생기므로 특성 선택 효과를 갖는다.

Ridge 회귀를 사용한 특성 선택은 주로 L2 정규화를 통해 특성의 가중치를 제어하여 수행된다. Ridge 회귀는 L2 정규화 항을 포함하고 있어, 가중치의 크기를 제한함으로써 모델의 복잡도를 조절한다.

from sklearn.datasets import load_iris
from sklearn.linear_model import Ridge
from sklearn.model_selection import train_test_split
import numpy as np

# 가상의 데이터셋을 사용 (iris 데이터셋)
iris = load_iris()
X = iris.data
y = iris.target

# 데이터를 훈련 세트와 테스트 세트로 나눔
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Ridge 회귀 모델 생성 및 학습
alpha = 0.1  # 정규화 강도를 조절하는 매개변수 (0.1은 예시로 조절 필요)
ridge_model = Ridge(alpha=alpha, random_state=42)
ridge_model.fit(X_train, y_train)

# 특성의 가중치 확인
feature_weights = ridge_model.coef_
print("Feature Weights:", feature_weights)

# 가중치가 0이 아닌 특성 선택
selected_features = np.where(feature_weights != 0)[0]
print("Selected Features:", selected_features)

coef_ 속성을 통해 특성의 가중치를 확인하고, 가중치가 0이 아닌 특성을 선택한다.

Recursive Feature Elimination (RFE):

RFE는 모델을 반복적으로 학습시켜 가장 중요하지 않은 특성을 제거하는 방법으로, 모델 성능이 가장 좋아지는 특성의 개수를 찾을 수 있다.
주로 RFE는 선형 모델과 함께 사용되며, 각 반복에서 중요하지 않은 특성들을 제거한다. 

from sklearn.datasets import load_iris
from sklearn.feature_selection import RFE
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split

# 가상의 데이터셋을 사용 (iris 데이터셋)
iris = load_iris()
X = iris.data
y = iris.target

# 데이터를 훈련 세트와 테스트 세트로 나눔
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 선형 회귀 모델 생성
model = LinearRegression()

# RFE를 사용하여 특성 선택 (예: 2개의 특성 선택)
num_features_to_select = 2
rfe = RFE(model, n_features_to_select=num_features_to_select)
X_train_rfe = rfe.fit_transform(X_train, y_train)

# 선택된 특성 확인
selected_features = [i for i, selected in enumerate(rfe.support_) if selected]
print("Selected Features:", selected_features)

nfeatures_to_select 매개변수를 통해 선택할 특성의 개수를 조절할 수 있다. 선택된 특성은 rfe.support 속성을 통해 확인할 수 있다.

이진분류 문제에서 feature selection

  1. 필터 방법
  2. REF
  3. Tree-based methods
  4. Regularization -> L1 정규화 (Lasso)

선형회귀 문제에서 feature selection

  1. REF
  2. 래퍼 방법
  3. Regularization -> L1 정규화 (Lasso)
profile
이수진
뇽안
다음 포스트

데이터 정규화

0개의 댓글