SuperModelingFactory 0.2.0__py3-none-any.whl

Modeling_Tool/Model/LRM_Tool.pyi

@@ -0,0 +1,47 @@
+# =============================================================================
+# Modeling_Tool.Model.LRM_Tool
+# -----------------------------------------------------------------------------
+# Copyright (c) 2026 Kyle Sun <github.com/Kyle-J-Sun>. All rights reserved.
+# SuperModelingFactory — Licensed under the Business Source License 1.1.
+#
+# This stub describes the public API of a closed-source module compiled to a
+# native extension (.so / .pyd). The original source is not distributed.
+# Production / commercial use requires a separate commercial license.
+#
+# FINGERPRINT: SMF-LRMTOOL-3703d3ce
+#   (Unique trace marker. Do not remove or alter — used for plagiarism
+#    detection across the public internet.)
+# =============================================================================
+
+import numpy as np
+import pandas as pd
+from sklearn.linear_model import LogisticRegression
+import logging
+
+def lr_model(mdlx, mdly, valx, valy, params_dict): ...
+def lr_varimp(model): ...
+def get_lr_statsmodel_summary(model, x, y, feature_names = None): ...
+def compute_aic(model, x, y): ...
+def compute_bic(model, x, y): ...
+
+class FeatureSelectionAnalyzer:
+    def __init__(self, significance_level = 0.05): ...
+    def chi2_selection(self, data, feature_cols, target_col): ...
+    def compute_vif(self, data): ...
+    def correlation_filter(self, data, threshold = 0.8): ...
+
+class LRMaster:
+    def __init__(self, params = None, model = None, varlist = None, tgt_name = None, standardize = False, scaler = None): ...
+    def set_data(self, data): ...
+    def fit(self, data, varlist, tgt_name, val_data = None, val_varlist = None, val_tgt_name = None): ...
+    def calibrate_model(self, model = None, train_df = None, method = 'sigmoid', cv = 5): ...
+    def eval_calibrated_outcome(self, evalset, plot = False): ...
+    def predict(self, data, varlist = None, calibrated_model = False): ...
+    def predict_proba(self, data, varlist = None, calibrated_model = False): ...
+    def get_variable_importance(self): ...
+    def get_statsmodel_summary(self, data = None, varlist = None, tgt_name = None): ...
+    def get_aic(self, data = None, varlist = None, tgt_name = None): ...
+    def get_bic(self, data = None, varlist = None, tgt_name = None): ...
+    def stepwise_selection(self, data, varlist, tgt_name, criterion = 'aic', direction = 'both', max_iter = 100, verbose = True): ...
+    def grid_search_params(self, data, varlist, tgt_name, eval_sets, param_grid, objective = 'oot_gap_penalized', primary_set = None, gap_ref_sets = None, metric = 'auc', refit = True, verbose = True): ...
+    def clone(self): ...

Modeling_Tool/Model/__init__.py

@@ -0,0 +1,61 @@
+"""
+Modeling module for credit modeling toolkit.
+"""
+
+from .LRM_Tool import (
+    lr_model,
+    lr_varimp,
+    get_lr_statsmodel_summary,
+    compute_aic,
+    compute_bic,
+    LRMaster,
+    FeatureSelectionAnalyzer,
+)
+
+from .GBM_Tool import (
+    set_num_leaves,
+    lgb_model,
+    lgb_varimp,
+    lgbm_quick_train,
+    xgb_model,
+    xgbm_quick_train,
+    xgb_varimp,
+    catboost_model,
+    catboost_varimp,
+    catboost_quick_train,
+    LightGBMModel,
+    XGBoostModel,
+    CatBoostModel,
+    GradientBoostingModel as _GradientBoostingModelBase,
+)
+
+GradientBoostingModel = _GradientBoostingModelBase
+try:
+    from .GBM_Search_Tool import _gbm_param_search, attach_gbm_param_search
+    attach_gbm_param_search(_GradientBoostingModelBase)
+    if not hasattr(_GradientBoostingModelBase, "param_search"):
+        class GradientBoostingModel(_GradientBoostingModelBase):
+            param_search = _gbm_param_search
+            best_params_ = None
+            search_results_ = None
+except Exception:
+    GradientBoostingModel = _GradientBoostingModelBase
+
+from .Backward_Tool import (
+    backward_lgbm,
+    backward_xgbm,
+    BackwardVariableEliminator,
+    BackwardEliminationAnalyzer,
+)
+
+__all__ = [
+    'lr_model', 'lr_varimp', 'get_lr_statsmodel_summary',
+    'compute_aic', 'compute_bic',
+    'LRMaster', 'FeatureSelectionAnalyzer',
+    'set_num_leaves', 'lgb_model', 'lgb_varimp', 'lgbm_quick_train',
+    'xgb_model', 'xgbm_quick_train', 'xgb_varimp',
+    'catboost_model', 'catboost_varimp', 'catboost_quick_train',
+    'LightGBMModel', 'XGBoostModel', 'CatBoostModel', 'GradientBoostingModel',
+    'backward_lgbm', 'backward_xgbm',
+    'BackwardVariableEliminator', 'BackwardEliminationAnalyzer',
+]

Modeling_Tool/Sample/Distribution_Adaptation.py

@@ -0,0 +1,131 @@
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.ensemble import HistGradientBoostingClassifier
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.calibration import CalibratedClassifierCV
+
+class DistributionAdaptation:
+    def __init__(self, method='density_ratio'):
+        """
+        初始化分布适配器
+        
+        Parameters:
+        -----------
+        method: str
+            'density_ratio': 密度比估计
+            'kl_divergence': KL散度加权
+            'covariate_shift': 协变量偏移修正
+        """
+        self.method = method
+        self.sample_weights = None
+        self.feature_importances = None
+        
+    def estimate_density_ratio(self, X_train, X_oot):
+        """
+        使用密度比估计方法计算样本权重
+        KLIEP/KMM等方法的简化实现
+        """
+        from sklearn.neighbors import KernelDensity
+        
+        # 使用KDE估计密度
+        kde_train = KernelDensity(kernel='gaussian', bandwidth=0.5)
+        kde_oot = KernelDensity(kernel='gaussian', bandwidth=0.5)
+        
+        kde_train.fit(X_train)
+        kde_oot.fit(X_oot)
+        
+        # 计算密度比: p_oot(x) / p_train(x)
+        log_density_train = kde_train.score_samples(X_train)
+        log_density_oot = kde_oot.score_samples(X_train)
+        
+        # 防止除零和数值不稳定
+        density_ratio = np.exp(log_density_oot - log_density_train)
+        
+        # 截断处理异常值
+        density_ratio = np.clip(density_ratio, 0.1, 10)
+        
+        # 归一化
+        density_ratio = density_ratio / density_ratio.mean()
+        
+        return density_ratio
+    
+    def covariate_shift_weighting(self, X_train, X_oot):
+        """
+        使用领域分类器估计样本重要性权重
+        """
+        from sklearn.linear_model import LogisticRegression
+        
+        # 创建领域标签: 训练集为0, OOT为1
+        n_train = len(X_train)
+        n_oot = len(X_oot)
+        
+        X_combined = np.vstack([X_train, X_oot])
+        y_domain = np.hstack([np.zeros(n_train), np.ones(n_oot)])
+        
+        # 训练领域分类器
+        domain_classifier = LogisticRegression(
+            C=1.0, max_iter=1000, random_state=42
+        )
+        domain_classifier.fit(X_combined, y_domain)
+        
+        # 预测训练样本来自OOT的概率
+        p_oot = domain_classifier.predict_proba(X_train)[:, 1]
+        
+        # 计算权重: p(oot|x) / p(train|x)
+        # 防止数值不稳定
+        epsilon = 1e-10
+        weights = p_oot / (1 - p_oot + epsilon)
+        
+        # 使用beta分布平滑权重
+        weights = np.clip(weights, 0.1, 10)
+        weights = weights / weights.mean()
+        
+        return weights
+    
+    def fit(self, X_train, X_oot, y_train=None):
+        """
+        计算适应OOT分布的样本权重
+        """
+        if self.method == 'density_ratio':
+            self.sample_weights = self.estimate_density_ratio(X_train, X_oot)
+        elif self.method == 'covariate_shift':
+            self.sample_weights = self.covariate_shift_weighting(X_train, X_oot)
+        else:
+            # 默认使用混合方法
+            w1 = self.estimate_density_ratio(X_train, X_oot)
+            w2 = self.covariate_shift_weighting(X_train, X_oot)
+            self.sample_weights = (w1 + w2) / 2
+        
+        return self
+    
+    def get_weights(self):
+        """返回样本权重"""
+        return self.sample_weights
+    
+    def visualize_distribution_comparison(self, X_train, X_oot, features=None, n_features=5):
+        """
+        可视化训练集和OOT集的分布差异
+        """
+        if features is None:
+            # 选择方差最大的特征
+            variances = np.var(X_train, axis=0)
+            features = np.argsort(variances)[-n_features:]
+        
+        fig, axes = plt.subplots(1, n_features, figsize=(5*n_features, 4))
+        
+        for idx, feature_idx in enumerate(features[:n_features]):
+            ax = axes[idx] if n_features > 1 else axes
+            
+            # 绘制分布
+            sns.kdeplot(X_train[:, feature_idx], ax=ax, label='Train', fill=True, alpha=0.5)
+            sns.kdeplot(X_oot[:, feature_idx], ax=ax, label='OOT', fill=True, alpha=0.5)
+            
+            ax.set_title(f'Feature {feature_idx}')
+            ax.legend()
+            ax.set_xlabel('Value')
+            ax.set_ylabel('Density')
+        
+        plt.tight_layout()
+        plt.show()

Modeling_Tool/Sample/Distribution_Adaptation.pyi

@@ -0,0 +1,30 @@
+# =============================================================================
+# Modeling_Tool.Sample.Distribution_Adaptation
+# -----------------------------------------------------------------------------
+# Copyright (c) 2026 Kyle Sun <github.com/Kyle-J-Sun>. All rights reserved.
+# SuperModelingFactory — Licensed under the Business Source License 1.1.
+#
+# This stub describes the public API of a closed-source module compiled to a
+# native extension (.so / .pyd). The original source is not distributed.
+# Production / commercial use requires a separate commercial license.
+#
+# FINGERPRINT: SMF-DISTRIBUTION-2dd20c74
+#   (Unique trace marker. Do not remove or alter — used for plagiarism
+#    detection across the public internet.)
+# =============================================================================
+
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.ensemble import HistGradientBoostingClassifier
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.calibration import CalibratedClassifierCV
+
+class DistributionAdaptation:
+    def __init__(self, method = 'density_ratio'): ...
+    def estimate_density_ratio(self, X_train, X_oot): ...
+    def covariate_shift_weighting(self, X_train, X_oot): ...
+    def fit(self, X_train, X_oot, y_train = None): ...
+    def get_weights(self): ...
+    def visualize_distribution_comparison(self, X_train, X_oot, features = None, n_features = 5): ...

Modeling_Tool/Sample/Reject_Infer.py

@@ -0,0 +1,413 @@
+"""
+Reject inference classes for credit modeling.
+
+This module provides classes for applying reject inference techniques
+to handle the selection bias in credit modeling when using
+approved loan data only.
+
+Classes
+-------
+RejectInferrer : Base class for reject inference.
+RejectInferenceFactory : Factory for creating reject inference methods.
+ParcelingInferrer : Parceling method for reject inference.
+FuzzyAugmentInferrer : Fuzzy augmentation method.
+HardCutoffInferrer : Hard cutoff method.
+SimpleAugmentInferrer : Simple augmentation method.
+
+Examples
+--------
+>>> from Modeling_Tool_refactored.sample import RejectInferrer
+>>> inferrer = RejectInferenceFactory.create('parceling')
+>>> df_inferred = inferrer.infer(df_approved, df_rejected, 'score')
+"""
+
+import pandas as pd
+import numpy as np
+from typing import Union, Optional, List, Dict, Any, Tuple
+from abc import ABC, abstractmethod
+
+
+class RejectInferrer(ABC):
+    """
+    Abstract base class for reject inference methods.
+    
+    Reject inference is used to address selection bias when building
+    credit models on approved loans only.
+    
+    Parameters
+    ----------
+    target_col : str, default 'target'
+        Name of the target column.
+    score_col : str, default 'score'
+        Name of the score/probability column.
+    
+    Methods
+    -------
+    infer(df_approved, df_rejected, score_col)
+        Apply reject inference.
+    """
+    
+    def __init__(self, target_col: str = 'target', 
+                 score_col: str = 'score'):
+        """
+        Initialize RejectInferrer.
+        
+        Parameters
+        ----------
+        target_col : str, default 'target'
+            Target column name.
+        score_col : str, default 'score'
+            Score column name.
+        """
+        self.target_col = target_col
+        self.score_col = score_col
+    
+    @abstractmethod
+    def infer(self, df_approved: pd.DataFrame,
+              df_rejected: pd.DataFrame,
+              score_col: Optional[str] = None) -> pd.DataFrame:
+        """
+        Apply reject inference.
+        
+        Parameters
+        ----------
+        df_approved : pandas.DataFrame
+            DataFrame with approved applications (has target).
+        df_rejected : pandas.DataFrame
+            DataFrame with rejected applications (no target).
+        score_col : str, optional
+            Score column name.
+        
+        Returns
+        -------
+        pandas.DataFrame
+            Combined DataFrame with inferred targets for rejected applications.
+        """
+        pass
+
+
+class SimpleAugmentInferrer(RejectInferrer):
+    """
+    Simple augmentation reject inference method.
+    
+    Assigns the average bad rate from approved applications
+    to all rejected applications.
+    
+    Parameters
+    ----------
+    bad_rate : float, optional
+        Override bad rate to use.
+    
+    Examples
+    --------
+    >>> inferrer = SimpleAugmentInferrer()
+    >>> df_combined = inferrer.infer(df_approved, df_rejected)
+    """
+    
+    def __init__(self, target_col: str = 'target', 
+                 score_col: str = 'score',
+                 bad_rate: Optional[float] = None):
+        """
+        Initialize SimpleAugmentInferrer.
+        """
+        super().__init__(target_col, score_col)
+        self.bad_rate = bad_rate
+    
+    def infer(self, df_approved: pd.DataFrame,
+              df_rejected: pd.DataFrame,
+              score_col: Optional[str] = None) -> pd.DataFrame:
+        """
+        Apply simple augmentation.
+        
+        Parameters
+        ----------
+        df_approved : pandas.DataFrame
+            Approved applications.
+        df_rejected : pandas.DataFrame
+            Rejected applications.
+        score_col : str, optional
+            Score column.
+        
+        Returns
+        -------
+        pandas.DataFrame
+            Combined data with inferred targets.
+        """
+        score_col = score_col or self.score_col
+        
+        if self.bad_rate is None:
+            bad_rate = df_approved[self.target_col].mean()
+        else:
+            bad_rate = self.bad_rate
+        
+        np.random.seed(42)
+        inferred_target = np.random.binomial(1, bad_rate, len(df_rejected))
+        
+        df_rejected_copy = df_rejected.copy()
+        df_rejected_copy[self.target_col] = inferred_target
+        
+        return pd.concat([df_approved, df_rejected_copy], ignore_index=True)
+
+
+class HardCutoffInferrer(RejectInferrer):
+    """
+    Hard cutoff reject inference method.
+    
+    Assigns all rejected applications below a score threshold
+    as bad (target=1), and all above as good (target=0).
+    
+    Parameters
+    ----------
+    cutoff : float, default 0.5
+        Score cutoff threshold.
+    
+    Examples
+    --------
+    >>> inferrer = HardCutoffInferrer(cutoff=0.3)
+    >>> df_combined = inferrer.infer(df_approved, df_rejected, 'probability')
+    """
+    
+    def __init__(self, target_col: str = 'target',
+                 score_col: str = 'score',
+                 cutoff: float = 0.5):
+        """
+        Initialize HardCutoffInferrer.
+        """
+        super().__init__(target_col, score_col)
+        self.cutoff = cutoff
+    
+    def infer(self, df_approved: pd.DataFrame,
+              df_rejected: pd.DataFrame,
+              score_col: Optional[str] = None) -> pd.DataFrame:
+        """
+        Apply hard cutoff inference.
+        
+        Parameters
+        ----------
+        df_approved : pandas.DataFrame
+            Approved applications.
+        df_rejected : pandas.DataFrame
+            Rejected applications.
+        score_col : str, optional
+            Score column.
+        
+        Returns
+        -------
+        pandas.DataFrame
+            Combined data with inferred targets.
+        """
+        score_col = score_col or self.score_col
+        
+        df_rejected_copy = df_rejected.copy()
+        df_rejected_copy[self.target_col] = (df_rejected_copy[score_col] < self.cutoff).astype(int)
+        
+        return pd.concat([df_approved, df_rejected_copy], ignore_index=True)
+
+
+class FuzzyAugmentInferrer(RejectInferrer):
+    """
+    Fuzzy augmentation reject inference method.
+    
+    Weights approved applications based on their predicted probability
+    and creates pseudo-target values for rejected applications.
+    
+    Parameters
+    ----------
+    weight_factor : float, default 1.0
+        Factor to adjust weights.
+    
+    Examples
+    --------
+    >>> inferrer = FuzzyAugmentInferrer(weight_factor=0.9)
+    >>> df_combined = inferrer.infer(df_approved, df_rejected, 'probability')
+    """
+    
+    def __init__(self, target_col: str = 'target',
+                 score_col: str = 'score',
+                 weight_factor: float = 1.0):
+        """
+        Initialize FuzzyAugmentInferrer.
+        """
+        super().__init__(target_col, score_col)
+        self.weight_factor = weight_factor
+    
+    def infer(self, df_approved: pd.DataFrame,
+              df_rejected: pd.DataFrame,
+              score_col: Optional[str] = None) -> pd.DataFrame:
+        """
+        Apply fuzzy augmentation.
+        
+        Parameters
+        ----------
+        df_approved : pandas.DataFrame
+            Approved applications.
+        df_rejected : pandas.DataFrame
+            Rejected applications.
+        score_col : str, optional
+            Score column.
+        
+        Returns
+        -------
+        pandas.DataFrame
+            Combined data with inferred targets.
+        """
+        score_col = score_col or self.score_col
+        
+        df_approved_copy = df_approved.copy()
+        df_rejected_copy = df_rejected.copy()
+        
+        proba = df_approved_copy[score_col]
+        df_approved_copy['_weight'] = (
+            proba * df_approved_copy[self.target_col] + 
+            (1 - proba) * (1 - df_approved_copy[self.target_col])
+        ) * self.weight_factor
+        
+        df_rejected_copy[self.target_col] = (1 - df_rejected_copy[score_col])
+        df_rejected_copy['_weight'] = 1.0
+        
+        return pd.concat([df_approved_copy, df_rejected_copy], ignore_index=True)
+
+
+class ParcelingInferrer(RejectInferrer):
+    """
+    Parceling reject inference method.
+    
+    Splits rejected applications into parcels based on score bands
+    and assigns average bad rate from approved applications in
+    each parcel.
+    
+    Parameters
+    ----------
+    n_parcels : int, default 10
+        Number of score parcels.
+    
+    Examples
+    --------
+    >>> inferrer = ParcelingInferrer(n_parcels=5)
+    >>> df_combined = inferrer.infer(df_approved, df_rejected, 'score')
+    """
+    
+    def __init__(self, target_col: str = 'target',
+                 score_col: str = 'score',
+                 n_parcels: int = 10):
+        """
+        Initialize ParcelingInferrer.
+        """
+        super().__init__(target_col, score_col)
+        self.n_parcels = n_parcels
+        self.parcel_rates_ = None
+    
+    def infer(self, df_approved: pd.DataFrame,
+              df_rejected: pd.DataFrame,
+              score_col: Optional[str] = None) -> pd.DataFrame:
+        """
+        Apply parceling inference.
+        
+        Parameters
+        ----------
+        df_approved : pandas.DataFrame
+            Approved applications.
+        df_rejected : pandas.DataFrame
+            Rejected applications.
+        score_col : str, optional
+            Score column.
+        
+        Returns
+        -------
+        pandas.DataFrame
+            Combined data with inferred targets.
+        """
+        score_col = score_col or self.score_col
+        
+        df_approved_copy = df_approved.copy()
+        df_rejected_copy = df_rejected.copy()
+        
+        df_approved_copy['_parcel'] = pd.qcut(
+            df_approved_copy[score_col], 
+            q=self.n_parcels, 
+            labels=False, 
+            duplicates='drop'
+        )
+        
+        parcel_rates = df_approved_copy.groupby('_parcel')[self.target_col].mean()
+        self.parcel_rates_ = parcel_rates
+        
+        df_rejected_copy['_parcel'] = pd.cut(
+            df_rejected_copy[score_col],
+            bins=self.n_parcels,
+            labels=False,
+            include_lowest=True
+        )
+        
+        df_rejected_copy[self.target_col] = df_rejected_copy['_parcel'].map(parcel_rates)
+        df_rejected_copy[self.target_col] = df_rejected_copy[self.target_col].fillna(
+            df_approved_copy[self.target_col].mean()
+        )
+        
+        df_approved_copy = df_approved_copy.drop('_parcel', axis=1)
+        df_rejected_copy = df_rejected_copy.drop('_parcel', axis=1)
+        
+        return pd.concat([df_approved_copy, df_rejected_copy], ignore_index=True)
+
+
+class RejectInferenceFactory:
+    """
+    Factory class for creating reject inference methods.
+    
+    Examples
+    --------
+    >>> inferrer = RejectInferenceFactory.create('parceling', n_parcels=5)
+    >>> inferrer = RejectInferenceFactory.create('fuzzy', weight_factor=0.9)
+    """
+    
+    _methods = {
+        'simple': SimpleAugmentInferrer,
+        'augment': SimpleAugmentInferrer,
+        'hard': HardCutoffInferrer,
+        'hardcutoff': HardCutoffInferrer,
+        'fuzzy': FuzzyAugmentInferrer,
+        'parceling': ParcelingInferrer,
+        'parcel': ParcelingInferrer
+    }
+    
+    @classmethod
+    def create(cls, method: str = 'parceling', **kwargs) -> RejectInferrer:
+        """
+        Create a reject inference method.
+        
+        Parameters
+        ----------
+        method : str, default 'parceling'
+            Method name.
+        **kwargs
+            Additional parameters for the method.
+        
+        Returns
+        -------
+        RejectInferrer
+            Instantiated reject inferrer.
+        
+        Raises
+        ------
+        ValueError
+            If method name is not recognized.
+        """
+        method_lower = method.lower()
+        if method_lower not in cls._methods:
+            raise ValueError(
+                f"Unknown method '{method}'. "
+                f"Available: {list(set(cls._methods.keys()))}"
+            )
+        return cls._methods[method_lower](**kwargs)
+    
+    @classmethod
+    def available_methods(cls) -> List[str]:
+        """
+        Get list of available methods.
+        
+        Returns
+        -------
+        list of str
+            Available method names.
+        """
+        return list(set(cls._methods.keys()))