from sklearn.ensemble import VotingClassifier, VotingRegressor
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.model_selection import cross_val_score

# Разнообразные базовые модели
base_models = [
    ('lr', LogisticRegression(random_state=42)),
    ('rf', RandomForestClassifier(n_estimators=100, random_state=42)),
    ('svm', SVC(probability=True, random_state=42))  # probability=True для soft voting
]

# Soft voting (рекомендуется для моделей с поддержкой вероятностей)
soft_ensemble = VotingClassifier(
    estimators=base_models,
    voting='soft',
    weights=[1, 2, 1]  # Дать RF больший вес
)

# Оценка ансамбля против индивидуальных моделей
for name, model in base_models + [('ensemble', soft_ensemble)]:
    scores = cross_val_score(model, X_train, y_train, cv=5, scoring='accuracy')
    print(f"{name}: {scores.mean():.3f} (+/- {scores.std() * 2:.3f})")

from sklearn.model_selection import KFold
from sklearn.base import clone
import numpy as np

class AdvancedStacker:
    def __init__(self, base_models, meta_model, cv_folds=5, use_probas=True):
        self.base_models = base_models
        self.meta_model = meta_model
        self.cv_folds = cv_folds
        self.use_probas = use_probas
        self.fitted_base_models = []

    def fit(self, X, y):
        kf = KFold(n_splits=self.cv_folds, shuffle=True, random_state=42)

        # Генерация out-of-fold предсказаний для мета-признаков
        meta_features = np.zeros((X.shape[0], len(self.base_models)))

        for i, (name, model) in enumerate(self.base_models):
            fold_preds = np.zeros(X.shape[0])

            for train_idx, val_idx in kf.split(X):
                fold_model = clone(model)
                fold_model.fit(X[train_idx], y[train_idx])

                if self.use_probas and hasattr(fold_model, 'predict_proba'):
                    fold_preds[val_idx] = fold_model.predict_proba(X[val_idx])[:, 1]
                else:
                    fold_preds[val_idx] = fold_model.predict(X[val_idx])

            meta_features[:, i] = fold_preds

            # Обучение на полном наборе данных для финальных предсказаний
            final_model = clone(model)
            final_model.fit(X, y)
            self.fitted_base_models.append((name, final_model))

        # Обучение мета-модели на мета-признаках
        self.meta_model.fit(meta_features, y)
        return self

    def predict(self, X):
        meta_features = np.zeros((X.shape[0], len(self.fitted_base_models)))

        for i, (name, model) in enumerate(self.fitted_base_models):
            if self.use_probas and hasattr(model, 'predict_proba'):
                meta_features[:, i] = model.predict_proba(X)[:, 1]
            else:
                meta_features[:, i] = model.predict(X)

        return self.meta_model.predict(meta_features)

# Пример использования
from sklearn.linear_model import Ridge
from xgboost import XGBClassifier

base_models = [
    ('rf', RandomForestClassifier(n_estimators=100, max_depth=5)),
    ('xgb', XGBClassifier(n_estimators=100, max_depth=3)),
    ('lr', LogisticRegression(C=0.1))
]

stacker = AdvancedStacker(
    base_models=base_models,
    meta_model=Ridge(alpha=0.1),  # Линейный мета-ученик
    cv_folds=5
)

class DynamicEnsemble:
    def __init__(self, base_models, k_neighbors=5):
        self.base_models = base_models
        self.k_neighbors = k_neighbors
        self.fitted_models = []
        self.competence_regions = []

    def fit(self, X, y):
        from sklearn.neighbors import NearestNeighbors

        # Обучение всех базовых моделей
        for name, model in self.base_models:
            fitted_model = clone(model)
            fitted_model.fit(X, y)
            self.fitted_models.append((name, fitted_model))

        # Расчет компетентности для каждой модели в локальных областях
        self.nn = NearestNeighbors(n_neighbors=self.k_neighbors)
        self.nn.fit(X)

        # Сохранение обучающих данных для расчета компетентности
        self.X_train = X.copy()
        self.y_train = y.copy()

        return self

    def predict(self, X):
        predictions = np.zeros(X.shape[0])

        for i, x in enumerate(X):
            # Поиск k ближайших соседей
            distances, indices = self.nn.kneighbors([x])
            local_X = self.X_train[indices[0]]
            local_y = self.y_train[indices[0]]

            # Расчет компетентности каждой модели в локальной области
            competences = []
            for name, model in self.fitted_models:
                local_preds = model.predict(local_X)
                accuracy = np.mean(local_preds == local_y)
                competences.append(accuracy)

            # Взвешенное предсказание на основе компетентности
            model_preds = [model.predict([x])[0] for _, model in self.fitted_models]
            weights = np.array(competences) / np.sum(competences)

            # Для классификации: взвешенное голосование
            predictions[i] = np.average(model_preds, weights=weights)

        return predictions.round().astype(int)  # Для классификации

from scipy.optimize import minimize
from sklearn.metrics import log_loss

def optimize_ensemble_weights(predictions, y_true, method='log_loss'):
    """
    Оптимизация весов ансамбля с использованием validation loss
    predictions: массив размера (n_samples, n_models)
    """
    n_models = predictions.shape[1]

    def objective(weights):
        weights = weights / np.sum(weights)  # Нормализация
        ensemble_pred = np.average(predictions, weights=weights, axis=1)

        if method == 'log_loss':
            return log_loss(y_true, ensemble_pred)
        else:
            return -accuracy_score(y_true, ensemble_pred > 0.5)

    # Ограничения: веса суммируются в 1 и неотрицательны
    constraints = {'type': 'eq', 'fun': lambda w: np.sum(w) - 1}
    bounds = [(0, 1) for _ in range(n_models)]

    # Начальное предположение: равные веса
    initial_weights = np.ones(n_models) / n_models

    result = minimize(objective, initial_weights, 
                     bounds=bounds, constraints=constraints)

    return result.x / np.sum(result.x)  # Обеспечение нормализации

def ensemble_diagnostics(models, X_val, y_val):
    """
    Комплексный анализ производительности ансамбля
    """
    results = {}
    predictions = {}

    # Производительность отдельных моделей
    for name, model in models:
        pred = model.predict_proba(X_val)[:, 1]
        predictions[name] = pred

        results[name] = {
            'auc': roc_auc_score(y_val, pred),
            'logloss': log_loss(y_val, pred),
            'accuracy': accuracy_score(y_val, pred > 0.5)
        }

    # Анализ попарной корреляции
    pred_df = pd.DataFrame(predictions)
    correlation_matrix = pred_df.corr()

    print("Матрица корреляции моделей:")
    print(correlation_matrix)

    # Метрики разнообразия
    avg_correlation = correlation_matrix.values[np.triu_indices_from(correlation_matrix.values, k=1)].mean()
    print(f"\nСредняя попарная корреляция: {avg_correlation:.3f}")
    print("Более низкая корреляция указывает на большее разнообразие")

    return results, correlation_matrix

# Использование
results, corr_matrix = ensemble_diagnostics(fitted_models, X_val, y_val)