머신러닝 알고리즘별 하이퍼파리미터

1. K-Nearest Neighbors (KNN)

KNN은 가까운 이웃들을 기반으로 예측을 수행합니다.

• 주요 하이퍼파라미터:
  • n_neighbors: 이웃의 개수 (기본값 = 5)
  • weights: 거리 가중치 (uniform 또는 distance)
  • p: 거리 계산 방식 (1 = 맨해튼 거리, 2 = 유클리드 거리)

from sklearn.linear_model import LogisticRegression
lr = LogisticRegression(C=0.1, solver='lbfgs', max_iter=500)

---

2. Decision Tree (의사결정 나무)

데이터를 조건문으로 분류하는 알고리즘입니다.

• 주요 하이퍼파라미터:
  • max_depth: 트리의 최대 깊이 (과적합 방지)
  • min_samples_split: 내부 노드를 나누는 최소 샘플 수
  • min_samples_leaf: 리프 노드에 필요한 최소 샘플 

from sklearn.tree import DecisionTreeClassifier
dt = DecisionTreeClassifier(max_depth=5, min_samples_split=10)

---

3. Random Forest (랜덤 포레스트)

여러 개의 결정 나무를 조합해 예측하는 모델입니다.

• 주요 하이퍼파라미터:
  • n_estimators: 생성할 트리 개수 (기본값 = 100)
  • max_depth: 각 트리의 최대 깊이
  • max_features: 각 노드에서 고려할 최대 특성 수

from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(n_estimators=200, max_depth=10, max_features='sqrt')

---

4. Logistic Regression (로지스틱 회귀)

이진 분류에 주로 사용되며 클래스에 속할 확률을 예측합니다.

• 주요 하이퍼파라미터:
  • C: 규제 강도 (작을수록 강한 규제)
  • solver: 최적화 알고리즘 (예: 'lbfgs', 'sag')
  • max_iter: 반복 횟수

from sklearn.linear_model import LogisticRegression
lr = LogisticRegression(C=0.1, solver='lbfgs', max_iter=500)

---

5. XGBoost (eXtreme Gradient Boosting)

부스팅을 통해 오차를 반복적으로 줄이는 강력한 모델입니다.

• 주요 하이퍼파라미터:
  • n_estimators: 부스팅 단계의 수
  • learning_rate: 학습 속도 (0.01~0.3 권장)
  • max_depth: 개별 트리의 최대 깊이
  • subsample: 각 부스팅 단계에 사용할 샘플 비율

from xgboost import XGBClassifier
xgb = XGBClassifier(n_estimators=100, learning_rate=0.1, max_depth=6, subsample=0.8)

---

하이퍼파라미터 튜닝 방법

1. GridSearchCV:
   • 여러 하이퍼파라미터의 조합을 모두 시도하며, 최적의 조합을 찾습니다.
    

from sklearn.model_selection import GridSearchCV

param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [3, 6, 9]
}
grid_search = GridSearchCV(XGBClassifier(), param_grid, cv=3, scoring='accuracy')
grid_search.fit(x_train, y_train)

print("Best parameters:", grid_search.best_params_)
print("Best score:", grid_search.best_score_)

 

 

1. RandomSearchCV:
   • 랜덤으로 여러 조합을 시도하며, 시간 절약이 가능합니다.
    

from sklearn.model_selection import RandomizedSearchCV

param_dist = {
    'n_estimators': [50, 100, 200],
    'learning_rate': [0.01, 0.1, 0.2]
}
random_search = RandomizedSearchCV(XGBClassifier(), param_dist, n_iter=10, cv=3, scoring='accuracy')
random_search.fit(x_train, y_train)

print("Best parameters:", random_search.best_params_)

 

 

 

 

파이프라인형식 함수로 앙상블 돌리기~~

 

import pandas as pd
import re
import joblib
import warnings
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.ensemble import VotingClassifier, StackingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import LabelEncoder, MinMaxScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

warnings.filterwarnings("ignore", category=UserWarning)

def complete_pipeline(file_path, target_col='Activity'):
    """
    파일 읽기, 전처리, 앙상블 선택 및 평가까지 모두 수행하는 함수.
    """

    # 1. 데이터 로드 및 전처리
    def clean_column_names(df):
        df = df.rename(columns=lambda x: re.sub('[^A-Za-z0-9_]+', '', x))
        print("특수문자 제거 완료.")
        return df

    data = pd.read_csv(file_path)
    print(f"데이터 로드 완료: {data.shape[0]}개의 샘플, {data.shape[1]}개의 특성")

    if 'subject' in data.columns:
        data.drop(columns='subject', inplace=True)

    data = clean_column_names(data)

    # 라벨 인코딩 및 디코더 객체 생성
    le = LabelEncoder()
    data[target_col] = le.fit_transform(data[target_col])

    x = data.drop(columns=target_col)
    y = data[target_col]

    x_train, x_val, y_train, y_val = train_test_split(
        x, y, test_size=0.2, random_state=1
    )
    print(f"데이터 분할 완료: 학습 {x_train.shape[0]}개, 검증 {x_val.shape[0]}개")

    scaler = MinMaxScaler()
    x_train_s = scaler.fit_transform(x_train)
    x_val_s = scaler.transform(x_val)
    print("스케일링 완료: MinMaxScaler 적용")

    # 2. 모델 로드 및 앙상블 생성
    def load_models(model_paths):
        models = []
        for name, path in model_paths.items():
            print(f"Loading model: {name} from {path}")
            model = joblib.load(path)
            models.append((name, model))
        print(f"{len(models)} models loaded successfully.")
        return models

    model_paths = {
        'lr': 'LogisticRegression.pkl',
        'knn': 'KNeighbors.pkl',
        'dt': 'DecisionTree.pkl',
        'rf': 'RandomForest.pkl',
        'svm': 'SVM.pkl',
        'lgbm': 'LGBM.pkl',
        'xgb': 'XGB.pkl',
        'knn_e': 'knn_e.pkl',
        'knn_m': 'knn_m.pkl',
        'xgb_n': 'xgb_n.pkl'
    }

    estimators = load_models(model_paths)

    # 사용자에게 앙상블 선택 요청
    ensemble_type = input("앙상블 방법을 선택하세요 (voting/stacking): ").strip().lower()

    if ensemble_type == 'voting':
        print("Voting 앙상블을 선택했습니다.")
        hv_model = VotingClassifier(estimators=estimators, voting='hard')
        sv_model = VotingClassifier(estimators=estimators, voting='soft', 
                                    weights=[1, 1, 2, 2, 1, 3, 3, 1, 2, 3])
        models = [('Hard Voting Ensemble', hv_model), 
                  ('Soft Voting Ensemble', sv_model)]
        
    elif ensemble_type == 'stacking':
        print("Stacking 앙상블을 선택했습니다.")
        model_stack = StackingClassifier(
            estimators=estimators, final_estimator=LogisticRegression(), n_jobs=-1
        )
        models = [('Stacking Ensemble', model_stack)]
    else:
        raise ValueError("잘못된 입력입니다. 'voting' 또는 'stacking'을 입력하세요.")

    # 3. 평가 및 시각화
    def plot_classification_report(y_val, y_pred):
        """
        Classification Report를 시각화하고 막대 위에 값 표시.
        """
        report = classification_report(y_val, y_pred, output_dict=True)
        report_df = pd.DataFrame(report).T.iloc[:-3, :-1]

        ax = report_df.plot(kind='bar', figsize=(12, 6))
        plt.title('Classification Report')
        plt.xlabel('Classes')
        plt.ylabel('Scores')
        plt.xticks(rotation=0)

        # 막대 위에 값 표시
        for p in ax.patches:
            ax.annotate(f'{p.get_height():.2f}', 
                        (p.get_x() + p.get_width() / 2, p.get_height()), 
                        ha='center', va='bottom')

        # 클래스 이름으로 x축 라벨 변경
        class_names = le.inverse_transform(report_df.index.astype(int))
        ax.set_xticklabels(class_names)
        plt.show()

    def plot_confusion_matrix(y_val, y_pred, title="Confusion Matrix"):
        cm = confusion_matrix(y_val, y_pred)
        plt.figure(figsize=(8, 6))
        sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', cbar=False)
        plt.title(title)
        plt.xlabel('Predicted')
        plt.ylabel('Actual')
        plt.show()

    def train_evaluate_and_visualize(model, model_name):
        print(f"\nTraining and evaluating {model_name}...")
        model.fit(x_train_s, y_train)
        predictions = model.predict(x_val_s)

        acc = accuracy_score(y_val, predictions)
        print(f"Accuracy: {acc:.2f}")
        print("Classification Report:")
        print(classification_report(y_val, predictions))

        plot_confusion_matrix(y_val, predictions, title=f"{model_name} - Confusion Matrix")
        plot_classification_report(y_val, predictions)

    # 4. 선택된 앙상블 모델 평가 및 시각화
    for model_name, model in models:
        train_evaluate_and_visualize(model, model_name)

file_path = 'data01_test.csv'
complete_pipeline(file_path)

 

 

이 함수를 쓰려면 이 파일과 같은경로에 알고리즘별 pkl 파일이 잇어야합니다

 

voting 과 stacking 방법중 선택해서 돌릴수 있습니다~~

그러면 정확도와 변수별 시각화가 나타납니다~~~

 

 

오늘의 복습은... 사실 할게 없음니다

왜냐면 하루종일 코드만 보앗기 때문입니다...