import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import load_iris, load_boston, fetch_california_housing
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler
from sklearn.preprocessing import OneHotEncoder, LabelEncoder
from sklearn.impute import SimpleImputer
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error
from sklearn.pipeline import Pipeline
from typing import Tuple, Dict, List, Any, Optional, Union

class DatasetPreparation:
    """
    머신러닝 모델 학습을 위한 데이터셋 준비 클래스
    """
    
    def __init__(self, random_state: int = 42):
        """
        초기화
        
        Args:
            random_state: 랜덤 시드
        """
        self.random_state = random_state
        self.X_train = None
        self.X_test = None
        self.y_train = None
        self.y_test = None
        self.scaler = None
        self.imputer = None
        
    def load_dataset(self, dataset_name: str = 'iris') -> Tuple[np.ndarray, np.ndarray]:
        """
        샘플 데이터셋 로드
        
        Args:
            dataset_name: 데이터셋 이름 ('iris', 'boston', 'california')
            
        Returns:
            Tuple: (X, y) 형태의 특성과 타겟 데이터
        """
        if dataset_name == 'iris':
            dataset = load_iris()
            X, y = dataset.data, dataset.target
            print(f"Iris 데이터셋 로드: {X.shape[0]} 샘플, {X.shape[1]} 특성, {len(np.unique(y))} 클래스")
        elif dataset_name == 'boston':
            dataset = load_boston()
            X, y = dataset.data, dataset.target
            print(f"Boston 주택 데이터셋 로드: {X.shape[0]} 샘플, {X.shape[1]} 특성")
        elif dataset_name == 'california':
            dataset = fetch_california_housing()
            X, y = dataset.data, dataset.target
            print(f"California 주택 데이터셋 로드: {X.shape[0]} 샘플, {X.shape[1]} 특성")
        else:
            # 커스텀 데이터 생성 (예시)
            X = np.random.rand(100, 4)  # 100개 샘플, 4개 특성
            y = np.random.randint(0, 2, 100)  # 이진 분류를 위한 레이블
            print(f"랜덤 데이터 생성: {X.shape[0]} 샘플, {X.shape[1]} 특성")
            
        return X, y
    
    def split_data(self, X: np.ndarray, y: np.ndarray, test_size: float = 0.2) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
        """
        학습 및 테스트 데이터 분할
        
        Args:
            X: 특성 데이터
            y: 타겟 데이터
            test_size: 테스트 세트 비율
            
        Returns:
            Tuple: (X_train, X_test, y_train, y_test) 형태의 분할된 데이터
        """
        X_train, X_test, y_train, y_test = train_test_split(
            X, y, test_size=test_size, random_state=self.random_state
        )
        
        self.X_train, self.X_test = X_train, X_test
        self.y_train, self.y_test = y_train, y_test
        
        print(f"데이터 분할: 학습 {X_train.shape[0]} 샘플, 테스트 {X_test.shape[0]} 샘플")
        return X_train, X_test, y_train, y_test
    
    def scale_data(self, scaler_type: str = 'standard') -> Tuple[np.ndarray, np.ndarray]:
        """
        데이터 스케일링
        
        Args:
            scaler_type: 스케일러 유형 ('standard', 'minmax', 'robust')
            
        Returns:
            Tuple: (X_train_scaled, X_test_scaled) 형태의 스케일링된 데이터
        """
        if self.X_train is None or self.X_test is None:
            raise ValueError("먼저 split_data를 호출하여 데이터를 분할해야 합니다")
            
        if scaler_type == 'standard':
            self.scaler = StandardScaler()
            print("StandardScaler 적용: 평균=0, 표준편차=1")
        elif scaler_type == 'minmax':
            self.scaler = MinMaxScaler()
            print("MinMaxScaler 적용: 범위=[0,1]")
        elif scaler_type == 'robust':
            self.scaler = RobustScaler()
            print("RobustScaler 적용: 중앙값=0, IQR 기반 스케일링")
        else:
            raise ValueError("지원되지 않는 스케일러 유형입니다")
            
        X_train_scaled = self.scaler.fit_transform(self.X_train)
        X_test_scaled = self.scaler.transform(self.X_test)
        
        return X_train_scaled, X_test_scaled
    
    def handle_missing_values(self, X: np.ndarray, strategy: str = 'mean') -> np.ndarray:
        """
        결측치 처리
        
        Args:
            X: 특성 데이터
            strategy: 대체 전략 ('mean', 'median', 'most_frequent', 'constant')
            
        Returns:
            np.ndarray: 결측치가 처리된 데이터
        """
        self.imputer = SimpleImputer(strategy=strategy)
        X_imputed = self.imputer.fit_transform(X)
        
        print(f"결측치 처리: {strategy} 전략 사용")
        return X_imputed
    
    def encode_categorical(self, X: np.ndarray, categorical_cols: List[int]) -> np.ndarray:
        """
        범주형 변수 인코딩
        
        Args:
            X: 특성 데이터
            categorical_cols: 범주형 변수의 인덱스 목록
            
        Returns:
            np.ndarray: 인코딩된 데이터
        """
        encoder = OneHotEncoder(sparse=False, drop='first')
        
        # 범주형 변수 추출
        X_cat = X[:, categorical_cols]
        # 수치형 변수 추출
        X_num = np.delete(X, categorical_cols, axis=1)
        
        # 범주형 변수 인코딩
        X_cat_encoded = encoder.fit_transform(X_cat)
        
        # 인코딩된 데이터와 수치형 데이터 결합
        X_encoded = np.hstack([X_num, X_cat_encoded])
        
        print(f"범주형 변수 인코딩: {len(categorical_cols)}개 변수, 원-핫 인코딩 적용")
        return X_encoded
    
    def create_pipeline(self, scaler_type: str = 'standard', impute_strategy: str = 'mean') -> Pipeline:
        """
        전처리 파이프라인 생성
        
        Args:
            scaler_type: 스케일러 유형
            impute_strategy: 결측치 대체 전략
            
        Returns:
            Pipeline: Scikit-learn 전처리 파이프라인
        """
        steps = []
        
        # 결측치 처리 단계 추가
        steps.append(('imputer', SimpleImputer(strategy=impute_strategy)))
        
        # 스케일링 단계 추가
        if scaler_type == 'standard':
            steps.append(('scaler', StandardScaler()))
        elif scaler_type == 'minmax':
            steps.append(('scaler', MinMaxScaler()))
        elif scaler_type == 'robust':
            steps.append(('scaler', RobustScaler()))
            
        pipeline = Pipeline(steps)
        print(f"전처리 파이프라인 생성: {' -> '.join([step[0] for step in steps])}")
        
        return pipeline
    
    def visualize_data(self, X: np.ndarray, y: np.ndarray, feature_names: Optional[List[str]] = None) -> None:
        """
        데이터 시각화
        
        Args:
            X: 특성 데이터
            y: 타겟 데이터
            feature_names: 특성 이름 목록
        """
        if feature_names is None:
            feature_names = [f'Feature_{i}' for i in range(X.shape[1])]
            
        # 특성 분포 확인
        plt.figure(figsize=(12, 8))
        for i in range(min(X.shape[1], 8)):  # 최대 8개 특성까지 표시
            plt.subplot(2, 4, i+1)
            plt.hist(X[:, i], bins=20)
            plt.title(feature_names[i])
        plt.tight_layout()
        plt.show()
        
        # 상관관계 확인 (최대 10개 특성까지)
        if X.shape[1] > 1:
            plt.figure(figsize=(10, 8))
            corr_matrix = np.corrcoef(X[:, :min(X.shape[1], 10)], rowvar=False)
            sns.heatmap(corr_matrix, annot=True, fmt='.2f', cmap='coolwarm',
                        xticklabels=feature_names[:min(X.shape[1], 10)],
                        yticklabels=feature_names[:min(X.shape[1], 10)])
            plt.title('특성 간 상관관계')
            plt.tight_layout()
            plt.show()
            
        # 타겟 분포 확인
        plt.figure(figsize=(8, 5))
        if len(np.unique(y)) <= 10:  # 분류 문제
            plt.hist(y, bins=len(np.unique(y)))
            plt.xticks(np.unique(y))
            plt.title('클래스 분포')
        else:  # 회귀 문제
            plt.hist(y, bins=30)
            plt.title('타겟 변수 분포')
        plt.xlabel('값')
        plt.ylabel('빈도')
        plt.show()

# 사용 예시
if __name__ == "__main__":
    # 데이터 준비 객체 생성
    data_prep = DatasetPreparation(random_state=42)
    
    # 데이터 로드
    X, y = data_prep.load_dataset('iris')
    
    # 데이터 분할
    X_train, X_test, y_train, y_test = data_prep.split_data(X, y, test_size=0.2)
    
    # 데이터 스케일링
    X_train_scaled, X_test_scaled = data_prep.scale_data('standard')
    
    # 전처리 파이프라인 생성
    pipeline = data_prep.create_pipeline(scaler_type='standard', impute_strategy='mean')
    
    # 데이터 시각화
    data_prep.visualize_data(X, y, feature_names=['sepal length', 'sepal width', 'petal length', 'petal width'])
    
    print("데이터 준비 완료!")

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split, learning_curve
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error

# 분류 모델
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB

# 회귀 모델
from sklearn.linear_model import LinearRegression, Ridge, Lasso, ElasticNet
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
from sklearn.svm import SVR

from typing import Dict, List, Any, Optional, Tuple, Union, Callable
import time
import joblib

class SupervisedModelTrainer:
    """
    다양한 지도 학습 모델을 훈련하고 평가하는 클래스
    """
    
    def __init__(self, random_state: int = 42):
        """
        초기화
        
        Args:
            random_state: 랜덤 시드 설정
        """
        self.random_state = random_state
        self.models = {}
        self.trained_models = {}
        self.results = {}
        
    def add_classification_models(self) -> None:
        """
        기본 분류 모델 추가
        """
        self.models = {
            'logistic_regression': LogisticRegression(random_state=self.random_state, max_iter=1000),
            'decision_tree': DecisionTreeClassifier(random_state=self.random_state),
            'random_forest': RandomForestClassifier(n_estimators=100, random_state=self.random_state),
            'svm': SVC(kernel='rbf', probability=True, random_state=self.random_state),
            'knn': KNeighborsClassifier(n_neighbors=5),
            'naive_bayes': GaussianNB(),
            'gradient_boosting': GradientBoostingClassifier(n_estimators=100, random_state=self.random_state)
        }
        print(f"{len(self.models)}개 분류 모델 추가됨")
        
    def add_regression_models(self) -> None:
        """
        기본 회귀 모델 추가
        """
        self.models = {
            'linear_regression': LinearRegression(),
            'ridge': Ridge(alpha=1.0, random_state=self.random_state),
            'lasso': Lasso(alpha=0.1, random_state=self.random_state),
            'elastic_net': ElasticNet(alpha=0.1, l1_ratio=0.5, random_state=self.random_state),
            'decision_tree': DecisionTreeRegressor(random_state=self.random_state),
            'random_forest': RandomForestRegressor(n_estimators=100, random_state=self.random_state),
            'svr': SVR(kernel='rbf'),
            'gradient_boosting': GradientBoostingRegressor(n_estimators=100, random_state=self.random_state)
        }
        print(f"{len(self.models)}개 회귀 모델 추가됨")
        
    def add_custom_model(self, name: str, model: Any) -> None:
        """
        사용자 정의 모델 추가
        
        Args:
            name: 모델 이름
            model: 모델 객체
        """
        self.models[name] = model
        print(f"사용자 정의 모델 '{name}' 추가됨")
        
    def train_models(self, X_train: np.ndarray, y_train: np.ndarray, verbose: bool = True) -> Dict[str, Any]:
        """
        모든 모델 훈련
        
        Args:
            X_train: 훈련 특성 데이터
            y_train: 훈련 타겟 데이터
            verbose: 상세 출력 여부
            
        Returns:
            Dict: 훈련된 모델 딕셔너리
        """
        if not self.models:
            raise ValueError("먼저 모델을 추가해야 합니다. add_classification_models() 또는 add_regression_models()를 호출하세요.")
            
        self.trained_models = {}
        
        for name, model in self.models.items():
            if verbose:
                print(f"'{name}' 모델 훈련 중...")
                
            start_time = time.time()
            model.fit(X_train, y_train)
            training_time = time.time() - start_time
            
            self.trained_models[name] = {
                'model': model,
                'training_time': training_time
            }
            
            if verbose:
                print(f"  훈련 완료: {training_time:.2f}초")
                
        print(f"{len(self.trained_models)}개 모델 훈련 완료")
        return self.trained_models
        
    def evaluate_classification_models(self, X_test: np.ndarray, y_test: np.ndarray, verbose: bool = True) -> Dict[str, Dict[str, Any]]:
        """
        분류 모델 평가
        
        Args:
            X_test: 테스트 특성 데이터
            y_test: 테스트 타겟 데이터
            verbose: 상세 출력 여부
            
        Returns:
            Dict: 모델별 평가 결과
        """
        if not self.trained_models:
            raise ValueError("먼저 모델을 훈련해야 합니다. train_models()를 호출하세요.")
            
        self.results = {}
        
        for name, model_info in self.trained_models.items():
            model = model_info['model']
            
            # 예측 수행
            start_time = time.time()
            y_pred = model.predict(X_test)
            prediction_time = time.time() - start_time
            
            # 성능 지표 계산
            accuracy = accuracy_score(y_test, y_pred)
            report = classification_report(y_test, y_pred, output_dict=True)
            
            # 결과 저장
            self.results[name] = {
                'accuracy': accuracy,
                'precision': report['weighted avg']['precision'],
                'recall': report['weighted avg']['recall'],
                'f1_score': report['weighted avg']['f1-score'],
                'training_time': model_info['training_time'],
                'prediction_time': prediction_time,
                'full_report': report
            }
            
            if verbose:
                print(f"\n--- {name} 모델 평가 결과 ---")
                print(f"정확도: {accuracy:.4f}")
                print(f"정밀도(가중평균): {report['weighted avg']['precision']:.4f}")
                print(f"재현율(가중평균): {report['weighted avg']['recall']:.4f}")
                print(f"F1 점수(가중평균): {report['weighted avg']['f1-score']:.4f}")
                print(f"훈련 시간: {model_info['training_time']:.2f}초")
                print(f"예측 시간: {prediction_time:.2f}초")
                
        print("\n모델 성능 비교 (정확도 기준)")
        for name, result in sorted(self.results.items(), key=lambda x: x[1]['accuracy'], reverse=True):
            print(f"{name}: {result['accuracy']:.4f}")
            
        return self.results
        
    def evaluate_regression_models(self, X_test: np.ndarray, y_test: np.ndarray, verbose: bool = True) -> Dict[str, Dict[str, Any]]:
        """
        회귀 모델 평가
        
        Args:
            X_test: 테스트 특성 데이터
            y_test: 테스트 타겟 데이터
            verbose: 상세 출력 여부
            
        Returns:
            Dict: 모델별 평가 결과
        """
        if not self.trained_models:
            raise ValueError("먼저 모델을 훈련해야 합니다. train_models()를 호출하세요.")
            
        self.results = {}
        
        for name, model_info in self.trained_models.items():
            model = model_info['model']
            
            # 예측 수행
            start_time = time.time()
            y_pred = model.predict(X_test)
            prediction_time = time.time() - start_time
            
            # 성능 지표 계산
            mse = mean_squared_error(y_test, y_pred)
            rmse = np.sqrt(mse)
            mae = mean_absolute_error(y_test, y_pred)
            r2 = r2_score(y_test, y_pred)
            
            # 결과 저장
            self.results[name] = {
                'mse': mse,
                'rmse': rmse,
                'mae': mae,
                'r2_score': r2,
                'training_time': model_info['training_time'],
                'prediction_time': prediction_time
            }
            
            if verbose:
                print(f"\n--- {name} 모델 평가 결과 ---")
                print(f"MSE: {mse:.4f}")
                print(f"RMSE: {rmse:.4f}")
                print(f"MAE: {mae:.4f}")
                print(f"R² 점수: {r2:.4f}")
                print(f"훈련 시간: {model_info['training_time']:.2f}초")
                print(f"예측 시간: {prediction_time:.2f}초")
                
        print("\n모델 성능 비교 (R² 점수 기준)")
        for name, result in sorted(self.results.items(), key=lambda x: x[1]['r2_score'], reverse=True):
            print(f"{name}: {result['r2_score']:.4f}")
            
        return self.results
        
    def plot_classification_results(self) -> None:
        """
        분류 모델 결과 시각화
        """
        if not self.results:
            raise ValueError("먼저 모델을 평가해야 합니다. evaluate_classification_models()를 호출하세요.")
            
        # 정확도 비교
        plt.figure(figsize=(12, 6))
        
        models = list(self.results.keys())
        accuracy = [result['accuracy'] for result in self.results.values()]
        
        plt.barh(models, accuracy, color='skyblue')
        plt.xlabel('정확도')
        plt.title('모델별 정확도 비교')
        plt.xlim(0, 1)
        
        for i, v in enumerate(accuracy):
            plt.text(v + 0.01, i, f"{v:.4f}", va='center')
            
        plt.tight_layout()
        plt.show()
        
        # 훈련 및 예측 시간 비교
        plt.figure(figsize=(12, 6))
        
        training_time = [result['training_time'] for result in self.results.values()]
        prediction_time = [result['prediction_time'] for result in self.results.values()]
        
        x = np.arange(len(models))
        width = 0.35
        
        plt.barh(x - width/2, training_time, width, label='훈련 시간', color='lightblue')
        plt.barh(x + width/2, prediction_time, width, label='예측 시간', color='lightgreen')
        
        plt.yticks(x, models)
        plt.xlabel('시간 (초)')
        plt.title('모델별 훈련 및 예측 시간 비교')
        plt.legend()
        
        plt.tight_layout()
        plt.show()
        
    def plot_regression_results(self) -> None:
        """
        회귀 모델 결과 시각화
        """
        if not self.results:
            raise ValueError("먼저 모델을 평가해야 합니다. evaluate_regression_models()를 호출하세요.")
            
        # R² 점수 비교
        plt.figure(figsize=(12, 6))
        
        models = list(self.results.keys())
        r2_scores = [result['r2_score'] for result in self.results.values()]
        
        plt.barh(models, r2_scores, color='skyblue')
        plt.xlabel('R² 점수')
        plt.title('모델별 R² 점수 비교')
        plt.xlim(0, 1)
        
        for i, v in enumerate(r2_scores):
            plt.text(v + 0.01, i, f"{v:.4f}", va='center')
            
        plt.tight_layout()
        plt.show()
        
        # RMSE 비교
        plt.figure(figsize=(12, 6))
        
        rmse_values = [result['rmse'] for result in self.results.values()]
        
        plt.barh(models, rmse_values, color='salmon')
        plt.xlabel('RMSE')
        plt.title('모델별 RMSE 비교')
        
        for i, v in enumerate(rmse_values):
            plt.text(v + 0.01, i, f"{v:.4f}", va='center')
            
        plt.tight_layout()
        plt.show()
        
    def plot_learning_curve(self, model_name: str, X: np.ndarray, y: np.ndarray, cv: int = 5) -> None:
        """
        학습 곡선 시각화
        
        Args:
            model_name: 모델 이름
            X: 전체 특성 데이터
            y: 전체 타겟 데이터
            cv: 교차 검증 폴드 수
        """
        if model_name not in self.trained_models:
            raise ValueError(f"'{model_name}' 모델이 훈련되지 않았습니다.")
            
        model = self.trained_models[model_name]['model']
        
        plt.figure(figsize=(10, 6))
        
        train_sizes, train_scores, test_scores = learning_curve(
            model, X, y, cv=cv, n_jobs=-1, 
            train_sizes=np.linspace(0.1, 1.0, 10),
            scoring='accuracy' if hasattr(model, 'predict_proba') else 'r2'
        )
        
        train_mean = np.mean(train_scores, axis=1)
        train_std = np.std(train_scores, axis=1)
        test_mean = np.mean(test_scores, axis=1)
        test_std = np.std(test_scores, axis=1)
        
        plt.plot(train_sizes, train_mean, 'o-', color='blue', label='훈련 점수')
        plt.fill_between(train_sizes, train_mean - train_std, train_mean + train_std, alpha=0.1, color='blue')
        
        plt.plot(train_sizes, test_mean, 'o-', color='green', label='교차 검증 점수')
        plt.fill_between(train_sizes, test_mean - test_std, test_mean + test_std, alpha=0.1, color='green')
        
        plt.xlabel('훈련 샘플 수')
        plt.ylabel('점수')
        plt.title(f'{model_name} 모델의 학습 곡선')
        plt.legend(loc='best')
        plt.grid(True)
        
        plt.tight_layout()
        plt.show()
        
    def save_model(self, model_name: str, filename: str) -> None:
        """
        모델 저장
        
        Args:
            model_name: 저장할 모델 이름
            filename: 저장할 파일 경로
        """
        if model_name not in self.trained_models:
            raise ValueError(f"'{model_name}' 모델이 훈련되지 않았습니다.")
            
        model = self.trained_models[model_name]['model']
        joblib.dump(model, filename)
        print(f"'{model_name}' 모델이 '{filename}'에 저장되었습니다.")
        
    def load_model(self, model_name: str, filename: str) -> Any:
        """
        모델 로드
        
        Args:
            model_name: 로드할 모델 이름
            filename: 로드할 파일 경로
            
        Returns:
            Any: 로드된 모델
        """
        model = joblib.load(filename)
        self.trained_models[model_name] = {'model': model, 'training_time': 0}
        print(f"'{filename}'에서 '{model_name}' 모델을 로드했습니다.")
        return model
        
    def get_best_model(self, metric: str = 'accuracy') -> Tuple[str, Any]:
        """
        최고 성능 모델 반환
        
        Args:
            metric: 평가 지표 ('accuracy', 'f1_score', 'r2_score', 'rmse' 등)
            
        Returns:
            Tuple: (모델 이름, 모델 객체)
        """
        if not self.results:
            raise ValueError("먼저 모델을 평가해야 합니다.")
            
        # 지표가 높을수록 좋은 경우 (accuracy, f1, r2 등)
        if metric in ['accuracy', 'precision', 'recall', 'f1_score', 'r2_score']:
            best_model_name = max(self.results, key=lambda x: self.results[x][metric])
        # 지표가 낮을수록 좋은 경우 (mse, rmse, mae 등)
        elif metric in ['mse', 'rmse', 'mae']:
            best_model_name = min(self.results, key=lambda x: self.results[x][metric])
        else:
            raise ValueError(f"지원되지 않는 평가 지표: {metric}")
            
        best_model = self.trained_models[best_model_name]['model']
        best_score = self.results[best_model_name][metric]
        
        print(f"최고 성능 모델: {best_model_name} ({metric}: {best_score:.4f})")
        return best_model_name, best_model

# 사용 예시
if __name__ == "__main__":
    # 데이터 준비
    from sklearn.datasets import load_breast_cancer
    
    data = load_breast_cancer()
    X, y = data.data, data.target
    
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    
    # 특성 스케일링
    scaler = StandardScaler()
    X_train_scaled = scaler.fit_transform(X_train)
    X_test_scaled = scaler.transform(X_test)
    
    # 모델 훈련 및 평가
    trainer = SupervisedModelTrainer(random_state=42)
    trainer.add_classification_models()
    trainer.train_models(X_train_scaled, y_train)
    results = trainer.evaluate_classification_models(X_test_scaled, y_test)
    
    # 결과 시각화
    trainer.plot_classification_results()
    
    # 최고 성능 모델 확인
    best_model_name, best_model = trainer.get_best_model('accuracy')
    
    # 학습 곡선 확인
    trainer.plot_learning_curve(best_model_name, X, y)
    
    # 모델 저장
    trainer.save_model(best_model_name, f'best_model_{best_model_name}.joblib')

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import StandardScaler, MinMaxScaler
from sklearn.cluster import KMeans, DBSCAN, AgglomerativeClustering
from sklearn.decomposition import PCA, TruncatedSVD, NMF
from sklearn.manifold import TSNE, Isomap
from sklearn.metrics import silhouette_score, calinski_harabasz_score
from sklearn.neighbors import NearestNeighbors
from sklearn.ensemble import IsolationForest
from sklearn.mixture import GaussianMixture

from typing import Dict, List, Any, Optional, Tuple, Union
import time
import matplotlib.cm as cm

class UnsupervisedLearning:
    """
    비지도 학습 알고리즘 적용 및 시각화 클래스
    """
    
    def __init__(self, random_state: int = 42):
        """
        초기화
        
        Args:
            random_state: 랜덤 시드
        """
        self.random_state = random_state
        self.data = None
        self.scaled_data = None
        self.cluster_labels = {}
        self.reduced_data = {}
        self.scaler = None
        
    def load_data(self, X: np.ndarray) -> np.ndarray:
        """
        데이터 로드 및 저장
        
        Args:
            X: 특성 데이터
            
        Returns:
            np.ndarray: 저장된 데이터
        """
        self.data = X
        print(f"데이터 로드: {X.shape[0]} 샘플, {X.shape[1]} 특성")
        return self.data
    
    def scale_data(self, method: str = 'standard') -> np.ndarray:
        """
        데이터 스케일링
        
        Args:
            method: 스케일링 방법 ('standard', 'minmax')
            
        Returns:
            np.ndarray: 스케일링된 데이터
        """
        if self.data is None:
            raise ValueError("먼저 load_data를 호출하여 데이터를 로드해야 합니다.")
            
        if method == 'standard':
            self.scaler = StandardScaler()
            print("StandardScaler 적용: 평균=0, 표준편차=1")
        elif method == 'minmax':
            self.scaler = MinMaxScaler()
            print("MinMaxScaler 적용: 범위=[0,1]")
        else:
            raise ValueError("지원되지 않는 스케일링 방법입니다.")
            
        self.scaled_data = self.scaler.fit_transform(self.data)
        return self.scaled_data
    
    def find_optimal_clusters(self, max_clusters: int = 10, method: str = 'elbow') -> int:
        """
        최적의 클러스터 수 찾기
        
        Args:
            max_clusters: 탐색할 최대 클러스터 수
            method: 방법 ('elbow', 'silhouette')
            
        Returns:
            int: 최적의 클러스터 수
        """
        if self.scaled_data is None:
            raise ValueError("먼저 scale_data를 호출하여 데이터를 스케일링해야 합니다.")
            
        data = self.scaled_data
        
        if method == 'elbow':
            # Elbow 방법
            inertia = []
            
            for k in range(1, max_clusters + 1):
                kmeans = KMeans(n_clusters=k, random_state=self.random_state)
                kmeans.fit(data)
                inertia.append(kmeans.inertia_)
                
            # 결과 시각화
            plt.figure(figsize=(10, 6))
            plt.plot(range(1, max_clusters + 1), inertia, marker='o')
            plt.title('Elbow Method for Optimal k')
            plt.xlabel('클러스터 수')
            plt.ylabel('관성 (Inertia)')
            plt.xticks(range(1, max_clusters + 1))
            plt.grid(True)
            plt.show()
            
            # 최적의 k 추정 (기울기 변화가 가장 큰 지점)
            k_diff = np.diff(inertia)
            k_diff2 = np.diff(k_diff)
            optimal_k = np.argmax(np.abs(k_diff2)) + 2  # +2: diff 연산으로 인한 인덱스 조정
            
            print(f"Elbow 방법으로 추정된 최적의 클러스터 수: {optimal_k}")
            
        elif method == 'silhouette':
            # 실루엣 방법
            silhouette_scores = []
            
            for k in range(2, max_clusters + 1):  # 실루엣 점수는 k >= 2 필요
                kmeans = KMeans(n_clusters=k, random_state=self.random_state)
                labels = kmeans.fit_predict(data)
                score = silhouette_score(data, labels)
                silhouette_scores.append(score)
                
            # 결과 시각화
            plt.figure(figsize=(10, 6))
            plt.plot(range(2, max_clusters + 1), silhouette_scores, marker='o')
            plt.title('Silhouette Method for Optimal k')
            plt.xlabel('클러스터 수')
            plt.ylabel('실루엣 점수 (Silhouette Score)')
            plt.xticks(range(2, max_clusters + 1))
            plt.grid(True)
            plt.show()
            
            # 최적의 k 추정 (실루엣 점수가 가장 높은 지점)
            optimal_k = np.argmax(silhouette_scores) + 2  # +2: k=2부터 시작하므로
            
            print(f"실루엣 방법으로 추정된 최적의 클러스터 수: {optimal_k}")
            
        else:
            raise ValueError("지원되지 않는 방법입니다.")
            
        return optimal_k
    
    def perform_clustering(self, algorithm: str = 'kmeans', params: Optional[Dict[str, Any]] = None) -> np.ndarray:
        """
        클러스터링 수행
        
        Args:
            algorithm: 클러스터링 알고리즘 ('kmeans', 'dbscan', 'hierarchical', 'gmm')
            params: 알고리즘 파라미터
            
        Returns:
            np.ndarray: 클러스터 레이블
        """
        if self.scaled_data is None:
            raise ValueError("먼저 scale_data를 호출하여 데이터를 스케일링해야 합니다.")
            
        data = self.scaled_data
        
        if params is None:
            params = {}
            
        if algorithm == 'kmeans':
            # KMeans 클러스터링
            n_clusters = params.get('n_clusters', 3)
            model = KMeans(
                n_clusters=n_clusters,
                random_state=self.random_state,
                n_init=params.get('n_init', 10)
            )
            
        elif algorithm == 'dbscan':
            # DBSCAN 클러스터링
            eps = params.get('eps', 0.5)
            min_samples = params.get('min_samples', 5)
            model = DBSCAN(
                eps=eps,
                min_samples=min_samples
            )
            
        elif algorithm == 'hierarchical':
            # 계층적 클러스터링
            n_clusters = params.get('n_clusters', 3)
            linkage = params.get('linkage', 'ward')
            model = AgglomerativeClustering(
                n_clusters=n_clusters,
                linkage=linkage
            )
            
        elif algorithm == 'gmm':
            # 가우시안 혼합 모델
            n_components = params.get('n_components', 3)
            model = GaussianMixture(
                n_components=n_components,
                random_state=self.random_state
            )
            
        else:
            raise ValueError("지원되지 않는 알고리즘입니다.")
            
        # 클러스터링 수행
        start_time = time.time()
        labels = model.fit_predict(data)
        duration = time.time() - start_time
        
        # 클러스터 통계
        unique_labels = np.unique(labels)
        n_clusters = len(unique_labels)
        n_noise = 0
        
        if algorithm == 'dbscan':
            n_noise = np.sum(labels == -1)
            print(f"DBSCAN 클러스터링 결과: {n_clusters} 클러스터, {n_noise} 노이즈 포인트")
        else:
            print(f"{algorithm.upper()} 클러스터링 결과: {n_clusters} 클러스터")
            
        # 클러스터별 샘플 수
        for label in unique_labels:
            if label == -1 and algorithm == 'dbscan':
                continue
            count = np.sum(labels == label)
            print(f"  클러스터 {label}: {count} 샘플 ({count/len(labels)*100:.1f}%)")
            
        # 클러스터링 평가 (실루엣 점수)
        if n_clusters > 1 and (algorithm != 'dbscan' or n_noise < len(labels)):
            try:
                if algorithm == 'dbscan' and n_noise > 0:
                    # 노이즈 포인트 제외 평가
                    non_noise_mask = (labels != -1)
                    silhouette = silhouette_score(data[non_noise_mask], labels[non_noise_mask])
                    calinski = calinski_harabasz_score(data[non_noise_mask], labels[non_noise_mask])
                else:
                    silhouette = silhouette_score(data, labels)
                    calinski = calinski_harabasz_score(data, labels)
                    
                print(f"실루엣 점수: {silhouette:.3f} (높을수록 좋음, 범위: [-1, 1])")
                print(f"Calinski-Harabasz 점수: {calinski:.3f} (높을수록 좋음)")
            except Exception as e:
                print(f"클러스터링 평가 오류: {e}")
                
        print(f"소요 시간: {duration:.3f}초")
        
        # 결과 저장
        self.cluster_labels[algorithm] = labels
        return labels
    
    def perform_dimension_reduction(self, algorithm: str = 'pca', n_components: int = 2) -> np.ndarray:
        """
        차원 축소 수행
        
        Args:
            algorithm: 차원 축소 알고리즘 ('pca', 'tsne', 'svd', 'nmf', 'isomap')
            n_components: 축소할 차원 수
            
        Returns:
            np.ndarray: 축소된 데이터
        """
        if self.scaled_data is None:
            raise ValueError("먼저 scale_data를 호출하여 데이터를 스케일링해야 합니다.")
            
        data = self.scaled_data
        
        if algorithm == 'pca':
            # PCA 차원 축소
            model = PCA(n_components=n_components, random_state=self.random_state)
            
        elif algorithm == 'tsne':
            # t-SNE 차원 축소
            model = TSNE(
                n_components=n_components,
                random_state=self.random_state,
                perplexity=min(30, data.shape[0] - 1)
            )
            
        elif algorithm == 'svd':
            # 절단된 SVD
            model = TruncatedSVD(n_components=n_components, random_state=self.random_state)
            
        elif algorithm == 'nmf':
            # 비음수 행렬 분해
            model = NMF(n_components=n_components, random_state=self.random_state)
            
        elif algorithm == 'isomap':
            # Isomap
            model = Isomap(n_components=n_components)
            
        else:
            raise ValueError("지원되지 않는 알고리즘입니다.")
            
        # 차원 축소 수행
        start_time = time.time()
        reduced_data = model.fit_transform(data)
        duration = time.time() - start_time
        
        print(f"{algorithm.upper()} 차원 축소 결과: {data.shape} → {reduced_data.shape}")
        print(f"소요 시간: {duration:.3f}초")
        
        # PCA의 경우 설명된 분산 비율 출력
        if algorithm == 'pca':
            explained_variance = model.explained_variance_ratio_
            cumulative_variance = np.cumsum(explained_variance)
            
            print(f"설명된 분산 비율: {explained_variance}")
            print(f"누적 설명된 분산 비율: {cumulative_variance[-1]:.3f}")
            
            # 설명된 분산 비율 시각화
            plt.figure(figsize=(10, 6))
            plt.bar(range(1, len(explained_variance) + 1), explained_variance, alpha=0.7)
            plt.step(range(1, len(cumulative_variance) + 1), cumulative_variance, where='mid', color='red')
            plt.ylabel('설명된 분산 비율')
            plt.xlabel('주성분')
            plt.title('PCA: 설명된 분산 비율')
            plt.show()
            
        # 결과 저장
        self.reduced_data[algorithm] = reduced_data
        return reduced_data
    
    def visualize_clusters(self, algorithm: str = 'kmeans', reduction_method: str = 'pca') -> None:
        """
        클러스터 시각화
        
        Args:
            algorithm: 클러스터링 알고리즘 이름
            reduction_method: 시각화를 위한 차원 축소 방법
        """
        if algorithm not in self.cluster_labels:
            raise ValueError(f"'{algorithm}' 클러스터링이 수행되지 않았습니다.")
            
        # 차원 축소된 데이터가 없는 경우 수행
        if reduction_method not in self.reduced_data:
            self.perform_dimension_reduction(algorithm=reduction_method, n_components=2)
            
        # 데이터와 레이블 준비
        reduced_data = self.reduced_data[reduction_method]
        labels = self.cluster_labels[algorithm]
        
        # 색상 맵 설정
        unique_labels = np.unique(labels)
        n_clusters = len(unique_labels)
        colors = cm.tab10(np.linspace(0, 1, max(10, n_clusters)))
        
        # 2D 시각화
        plt.figure(figsize=(12, 10))
        
        for i, label in enumerate(unique_labels):
            if label == -1:  # 노이즈 포인트 (DBSCAN)
                color = 'black'
                marker = 'x'
                label_name = 'Noise'
            else:
                color = colors[i % len(colors)]
                marker = 'o'
                label_name = f'Cluster {label}'
                
            mask = (labels == label)
            plt.scatter(
                reduced_data[mask, 0],
                reduced_data[mask, 1],
                c=[color],
                marker=marker,
                label=label_name,
                alpha=0.7,
                s=70
            )
            
        plt.title(f'{algorithm.upper()} Clustering with {reduction_method.upper()} Visualization')
        plt.xlabel(f'{reduction_method.upper()} Component 1')
        plt.ylabel(f'{reduction_method.upper()} Component 2')
        plt.legend()
        plt.grid(True, linestyle='--', alpha=0.7)
        plt.tight_layout()
        plt.show()
        
        # 3D 시각화 (3차원으로 축소된 경우)
        if reduction_method in self.reduced_data and self.reduced_data[reduction_method].shape[1] >= 3:
            from mpl_toolkits.mplot3d import Axes3D
            
            fig = plt.figure(figsize=(12, 10))
            ax = fig.add_subplot(111, projection='3d')
            
            for i, label in enumerate(unique_labels):
                if label == -1:  # 노이즈 포인트 (DBSCAN)
                    color = 'black'
                    marker = 'x'
                    label_name = 'Noise'
                else:
                    color = colors[i % len(colors)]
                    marker = 'o'
                    label_name = f'Cluster {label}'
                    
                mask = (labels == label)
                ax.scatter(
                    reduced_data[mask, 0],
                    reduced_data[mask, 1],
                    reduced_data[mask, 2],
                    c=[color],
                    marker=marker,
                    label=label_name,
                    alpha=0.7,
                    s=70
                )
                
            ax.set_title(f'{algorithm.upper()} Clustering with {reduction_method.upper()} 3D Visualization')
            ax.set_xlabel(f'{reduction_method.upper()} Component 1')
            ax.set_ylabel(f'{reduction_method.upper()} Component 2')
            ax.set_zlabel(f'{reduction_method.upper()} Component 3')
            ax.legend()
            plt.tight_layout()
            plt.show()
    
    def detect_anomalies(self, method: str = 'isolation_forest', contamination: float = 0.05) -> np.ndarray:
        """
        이상치 탐지
        
        Args:
            method: 이상치 탐지 방법 ('isolation_forest', 'lof')
            contamination: 이상치 비율 추정치
            
        Returns:
            np.ndarray: 이상치 레이블 (1: 정상, -1: 이상치)
        """
        if self.scaled_data is None:
            raise ValueError("먼저 scale_data를 호출하여 데이터를 스케일링해야 합니다.")
            
        data = self.scaled_data
        
        if method == 'isolation_forest':
            # 아이솔레이션 포레스트
            model = IsolationForest(
                contamination=contamination,
                random_state=self.random_state
            )
            
        elif method == 'lof':
            # Local Outlier Factor
            from sklearn.neighbors import LocalOutlierFactor
            model = LocalOutlierFactor(
                n_neighbors=20,
                contamination=contamination
            )
            
        else:
            raise ValueError("지원되지 않는 이상치 탐지 방법입니다.")
            
        # 이상치 탐지 수행
        start_time = time.time()
        
        if method == 'lof':
            # LOF는 fit_predict를 한 번에 호출해야 함
            labels = model.fit_predict(data)
        else:
            model.fit(data)
            labels = model.predict(data)
            
        duration = time.time() - start_time
        
        # 이상치 통계
        n_samples = data.shape[0]
        n_outliers = np.sum(labels == -1)
        outlier_ratio = n_outliers / n_samples
        
        print(f"{method.upper()} 이상치 탐지 결과:")
        print(f"  전체 샘플: {n_samples}")
        print(f"  이상치: {n_outliers} ({outlier_ratio:.1%})")
        print(f"  정상 데이터: {n_samples - n_outliers} ({1 - outlier_ratio:.1%})")
        print(f"소요 시간: {duration:.3f}초")
        
        # 결과 저장
        self.cluster_labels[method] = labels
        return labels
    
    def visualize_anomalies(self, method: str = 'isolation_forest', reduction_method: str = 'pca') -> None:
        """
        이상치 시각화
        
        Args:
            method: 이상치 탐지 방법
            reduction_method: 시각화를 위한 차원 축소 방법
        """
        if method not in self.cluster_labels:
            raise ValueError(f"'{method}' 이상치 탐지가 수행되지 않았습니다.")
            
        # 차원 축소된 데이터가 없는 경우 수행
        if reduction_method not in self.reduced_data:
            self.perform_dimension_reduction(algorithm=reduction_method, n_components=2)
            
        # 데이터와 레이블 준비
        reduced_data = self.reduced_data[reduction_method]
        labels = self.cluster_labels[method]
        
        # 2D 시각화
        plt.figure(figsize=(12, 10))
        
        # 정상 데이터
        normal_mask = (labels == 1)
        plt.scatter(
            reduced_data[normal_mask, 0],
            reduced_data[normal_mask, 1],
            c='blue',
            marker='o',
            label='Normal',
            alpha=0.5
        )
        
        # 이상치
        outlier_mask = (labels == -1)
        plt.scatter(
            reduced_data[outlier_mask, 0],
            reduced_data[outlier_mask, 1],
            c='red',
            marker='x',
            label='Anomaly',
            alpha=0.7,
            s=100
        )
            
        plt.title(f'{method.upper()} Anomaly Detection with {reduction_method.upper()} Visualization')
        plt.xlabel(f'{reduction_method.upper()} Component 1')
        plt.ylabel(f'{reduction_method.upper()} Component 2')
        plt.legend()
        plt.grid(True, linestyle='--', alpha=0.7)
        plt.tight_layout()
        plt.show()

# 사용 예시
if __name__ == "__main__":
    # 데이터 준비
    from sklearn.datasets import make_blobs
    
    # 샘플 데이터 생성
    X, y = make_blobs(
        n_samples=1000,
        n_features=10,
        centers=5,
        cluster_std=1.0,
        random_state=42
    )
    
    # 비지도 학습 객체 생성
    unsupervised = UnsupervisedLearning(random_state=42)
    
    # 데이터 로드 및 스케일링
    unsupervised.load_data(X)
    unsupervised.scale_data()
    
    # 최적의 클러스터 수 찾기
    optimal_k = unsupervised.find_optimal_clusters(max_clusters=10, method='silhouette')
    
    # 클러스터링 수행
    labels = unsupervised.perform_clustering(
        algorithm='kmeans',
        params={'n_clusters': optimal_k}
    )
    
    # 차원 축소 수행
    reduced_data = unsupervised.perform_dimension_reduction(algorithm='pca', n_components=2)
    
    # 클러스터 시각화
    unsupervised.visualize_clusters(algorithm='kmeans', reduction_method='pca')
    
    # 이상치 탐지
    anomaly_labels = unsupervised.detect_anomalies(method='isolation_forest', contamination=0.05)
    
    # 이상치 시각화
    unsupervised.visualize_anomalies(method='isolation_forest', reduction_method='pca')

from sklearn.model_selection import cross_val_score
from sklearn.metrics import confusion_matrix
from sklearn.model_selection import GridSearchCV

# 교차 검증
cv_scores = cross_val_score(rf_model, X_train_scaled, y_train, cv=5)
print(f"교차 검증 점수: {cv_scores.mean():.3f} (+/- {cv_scores.std() * 2:.3f})")

# 그리드 서치
param_grid = {
    'n_estimators': [100, 200, 300],
    'max_depth': [10, 20, 30, None]
}

grid_search = GridSearchCV(
    RandomForestClassifier(random_state=42),
    param_grid,
    cv=5
)

grid_search.fit(X_train_scaled, y_train)
print(f"최적 파라미터: {grid_search.best_params_}")

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.impute import SimpleImputer

# 전처리와 모델링 파이프라인
pipeline = Pipeline([
    ('imputer', SimpleImputer(strategy='mean')),
    ('scaler', StandardScaler()),
    ('classifier', RandomForestClassifier())
])

# 파이프라인 실행
pipeline.fit(X_train, y_train)
pipeline_pred = pipeline.predict(X_test)

# 파이프라인 평가
print(classification_report(y_test, pipeline_pred))

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.pipeline import Pipeline

class TextClassifier:
    def __init__(self):
        self.pipeline = Pipeline([
            ('tfidf', TfidfVectorizer()),
            ('classifier', MultinomialNB())
        ])
    
    def train(self, texts, labels):
        self.pipeline.fit(texts, labels)
    
    def predict(self, texts):
        return self.pipeline.predict(texts)
    
    def evaluate(self, texts, true_labels):
        pred_labels = self.predict(texts)
        return classification_report(true_labels, pred_labels)

from sklearn.ensemble import IsolationForest
from sklearn.preprocessing import StandardScaler

class AnomalyDetector:
    def __init__(self, contamination=0.1):
        self.scaler = StandardScaler()
        self.detector = IsolationForest(
            contamination=contamination,
            random_state=42
        )
    
    def fit(self, data):
        scaled_data = self.scaler.fit_transform(data)
        self.detector.fit(scaled_data)
    
    def predict(self, data):
        scaled_data = self.scaler.transform(data)
        predictions = self.detector.predict(scaled_data)
        return predictions == -1  # True for anomalies
    
    def get_anomaly_scores(self, data):
        scaled_data = self.scaler.transform(data)
        return -self.detector.score_samples(scaled_data)