Automl Skill

import statsmodels.api as sm

# OLS 回归（带统计显著性）
X = sm.add_constant(X)  # 添加截距
model = sm.OLS(y, X).fit()
print(model.summary())  # R², F检验, P值, 置信区间

# 二项分布 GLM (Logistic 回归)
glm_model = sm.GLM(y, X, family=sm.families.Binomial()).fit()

# 泊松回归 (计数数据)
poisson_model = sm.GLM(y, X, family=sm.families.Poisson()).fit()

from scipy import stats

# t 检验
t_stat, p_value = stats.ttest_ind(group1, group2)

# 卡方检验
chi2, p_value, dof, expected = stats.chi2_contingency(contingency_table)

# ANOVA
f_stat, p_value = stats.f_oneway(*groups)

from statsmodels.tsa.arima.model import ARIMA
from statsmodels.tsa.statespace.sarimax import SARIMAX

# ARIMA 模型
arima_model = ARIMA(train_data, order=(1,1,1)).fit()
forecast = arima_model.forecast(steps=12)

# 季节性 SARIMAX
sarimax_model = SARIMAX(data, order=(1,1,1), seasonal_order=(1,1,1,12)).fit()

# 残差自相关检验 (Durbin-Watson)
from statsmodels.stats.stattools import durbin_watson
dw = durbin_watson(model.resid)

# 异方差检验
from statsmodels.stats.diagnostic import het_breuschpagan
bp_test = het_breuschpagan(model.resid, model.model.exog)

# 正态性检验
from scipy import stats
shapiro_stat, shapiro_p = stats.shapiro(model.resid)

# 混合线性模型 (Panel Data / 多层次数据)
from statsmodels.regression.mixed_linear_model import MixedLM
mixed_model = MixedLM(y, X, groups=group_var).fit()

# 1. 用 PyCaret 快速建模和选择模型
from pycaret.classification import *
clf = setup(data, target='target')
best = compare_models()
tuned = tune_model(best)

# 2. 用 statsmodels 做统计推断
import statsmodels.api as sm
# 获取 PyCaret 模型的特征和预测
X_with_const = sm.add_constant(X_test)
sm_model = sm.Logit(y_test, X_with_const).fit(disp=0)
print(sm_model.summary())  # 系数显著性 P值

# 数据加载
import pandas as pd
train = pd.read_csv('train.csv')
test = pd.read_csv('test.csv')

# 或使用 PyCaret 内置数据集
from pycaret.classification import get_data
data = get_data('breast_cancer')

# 基本信息
print(f"数据形状: {data.shape}")
print(f"数据类型:\n{data.dtypes}")

# 缺失值分析
missing = data.isnull().sum()
missing_pct = (missing / len(data) * 100).round(2)
print(f"缺失值比例:\n{pd.concat([missing, missing_pct], axis=1)}")

# 目标变量分布
data['target'].value_counts()

# 数值特征统计
data.describe()

# 初始化环境 - 数据预处理配置
clf = setup(
    data,
    target='target',

    # ===== 缺失值处理 =====
    numeric_imputation='mean',       # 数值型: mean/median/mode/knn/iterative
    categorical_imputation='mode',   # 类别型: mode/constant

    # ===== 异常值处理 =====
    remove_outliers=True,           # 移除异常值
    outliers_method='iforest',      # iforest/ee/lof
    outliers_threshold=0.05,        # 异常值比例

    # ===== 类别不平衡处理 =====
    fix_imbalance=True,             # 处理类别不平衡
    fix_imbalance_method='SMOTE',  # SMOTE/ADASYN/RandomOverSampler

    # ===== 数据类型指定 =====
    numeric_features=['age', 'income', 'score'],
    categorical_features=['city', 'gender', 'occupation'],
    date_features=['Date', 'created_at'],

    session_id=42
)

clf = setup(
    data,
    target='target',

    # ===== 特征缩放 =====
    normalize=True,                 # 归一化
    normalize_method='zscore',     # zscore/minmax/maxabs/robust

    # ===== 特征变换 =====
    transformation=True,            # 变换使数据更接近正态分布
    transformation_method='yeo-johnson',  # yeo-johnson/quantile

    # ===== 特征选择 =====
    feature_selection=True,         # 特征选择
    feature_selection_method='classic',      # classic/univariate/sequential
    n_features_to_select=0.2,     # 选择20%最重要特征

    # ===== 降维 =====
    pca=True,                      # PCA降维
    pca_method='linear',           # linear/kernel/incremental
    pca_components=0.95,           # 保留95%方差

    # ===== 多重共线性处理 =====
    remove_multicollinearity=True,
    multicollinearity_threshold=0.9,

    # ===== 特征编码 =====
    ordinal_features={'education': ['high_school', 'bachelor', 'master', 'phd']},
    high_cardinality_features='frequency',  # 处理高基数类别特征

    # ===== 特征交互 =====
    polynomial_features=True,
    polynomial_degree=2,

    # ===== 分箱（离散化） =====
    bin_numeric_features=['age', 'income'],

    session_id=42
)

# 比较所有模型
best_model = compare_models()

# 指定模型列表比较
best_model = compare_models(include=['lr', 'rf', 'xgboost', 'catboost', 'lightgbm'])

# 快速模式（排除耗时模型）
best_model = compare_models(turbo=True)

# 按特定指标排序
best_model = compare_models(sort='F1')  # 对于不平衡数据

# 创建模型
model = create_model('rf')

# 指定模型参数
model = create_model('xgboost', n_estimators=100, max_depth=5)

# 自动调优
tuned_model = tune_model(model)

# 自定义调优
tuned_model = tune_model(
    model,
    custom_grid={
        'n_estimators': [100, 200, 300],
        'max_depth': [3, 5, 7, None],
        'learning_rate': [0.01, 0.1, 0.3]
    },
    optimize='Accuracy',           # 分类: Accuracy/AUC/Recall/Precision/F1/MCC
                                  # 回归: RMSE/MSE/MAE/R2/RMSLE/MAPE
    choose_better=True,            # 返回更好的模型
    n_iter=50                      # 迭代次数
)

# 交互式评估
evaluate_model(tuned_model)

# 各种评估图表
plot_model(tuned_model, plot='auc')                # ROC曲线
plot_model(tuned_model, plot='confusion_matrix')   # 混淆矩阵
plot_model(tuned_model, plot='classification_report')  # 分类报告
plot_model(tuned_model, plot='learning_curve')    # 学习曲线
plot_model(tuned_model, plot='feature')            # 特征重要性
plot_model(tuned_model, plot='residuals')          # 残差图（回归）
plot_model(tuned_model, plot='error')              # 预测误差

# 交叉验证结果
results = pull()  # 获取当前实验结果

# SHAP 解释
interpret_model(tuned_model)

# Permutation Importance
interpret_model(tuned_model, plot='correlation')

# 局部解释
interpret_model(tuned_model, plot='reason', observation=0)

# Bagging
bagged = ensemble_model(tuned_model, method='Bagging')

# Boosting
boosted = ensemble_model(tuned_model, method='Boosting')

# 融合多个模型
blended = blend_models(
    estimator_list=['lr', 'dt', 'rf', 'xgboost'],
    method='soft',                  # soft/hard
    weights=[1, 2, 3, 2]           # 各模型权重
)

# 堆叠
stacked = stack_models(
    estimator_list=['lr', 'dt', 'rf'],
    meta_model='xgboost',
    restack=False                   # 是否允许基础模型使用原始特征
)

# 在全部数据上训练最终模型
final_model = finalize_model(tuned_model)

# 预测
predictions = predict_model(final_model, data=test)

# 预测概率（分类）
predictions = predict_model(
    final_model,
    data=test,
    probability_threshold=0.7       # 自定义阈值
)

# 保存模型（包含完整Pipeline）
save_model(final_model, 'my_model')

# 保存实验配置
save_experiment('my_experiment')

# 加载模型
loaded_model = load_model('my_model')

# 部署到云平台
deploy_model(
    final_model,
    platform='aws',                 # aws/gcp/azure
    authentication={
        'bucket': 'my-bucket'
    }
)

# 创建Web应用
create_app(final_model, app_path='app.py')

# 创建REST API
create_api(final_model, api_name='predict', api_file='predict.py')

# 创建Docker
create_docker('my_model', docker_path='Dockerfile')

from pycaret.classification import *
import pandas as pd

# ========== Step 1: 数据加载 ==========
train = pd.read_csv('train.csv')
test = pd.read_csv('test.csv')

# ========== Step 2: 数据探索 ==========
print(f"训练集: {train.shape}, 测试集: {test.shape}")
print(f"缺失值:\n{train.isnull().sum()}")
print(f"目标分布:\n{train['target'].value_counts()}")

# ========== Step 3-4: 数据预处理 + 特征工程 ==========
clf = setup(
    train,
    target='target',

    # 数据预处理
    numeric_imputation='median',
    categorical_imputation='mode',
    remove_outliers=True,
    outliers_method='iforest',
    fix_imbalance=True,
    fix_imbalance_method='SMOTE',

    # 特征工程
    normalize=True,
    normalize_method='zscore',
    feature_selection=True,
    n_features_to_select=0.3,
    remove_multicollinearity=True,
    polynomial_features=True,
    polynomial_degree=2,

    # 划分配置
    train_size=0.8,
    fold_strategy='stratifiedkfold',
    fold=5,

    session_id=42
)

# ========== Step 5: 模型选择 ==========
best = compare_models(sort='AUC')

# ========== Step 6-7: 训练与调优 ==========
tuned = tune_model(best, optimize='AUC', n_iter=30)

# ========== Step 8-9: 评估与解释 ==========
evaluate_model(tuned)
interpret_model(tuned)

# ========== Step 10: 集成（可选） ==========
# ensemble = ensemble_model(tuned)

# ========== Step 11: 最终预测 ==========
final = finalize_model(tuned)
predictions = predict_model(final, data=test)

# ========== Step 12: 保存 ==========
save_model(final, 'best_model')

from pycaret.classification import get_data

# 列出数据集
all_datasets = get_data('index')

# 加载数据集
data = get_data('breast_cancer')

from pycaret.classification import get_config, set_config

# 获取配置
X_train = get_config('X_train')

# 设置配置
set_config('seed', 123)

# 比较模型
best = compare_models()

# 创建模型
model = create_model('rf')

# 调优模型
tuned = tune_model(model)

# 集成
ensemble = ensemble_model(model)

# 预测
predictions = predict_model(model, data=new_data)

# 保存/加载
save_model(model, 'my_model')
loaded = load_model('my_model')

from pycaret.classification import *

data = pd.read_csv('train.csv')
test = pd.read_csv('test.csv')

clf = setup(data, target='target', train_size=0.8)
best = compare_models()
tuned = tune_model(best)
ensemble = ensemble_model(tuned)
predictions = predict_model(ensemble, data=test)
save_model(ensemble, 'classifier')

from pycaret.regression import *

data = pd.read_csv('train.csv')
test = pd.read_csv('test.csv')

reg = setup(data, target='price', normalize=True)
best = compare_models()
tuned = tune_model(best, optimize='RMSE')
predictions = predict_model(tuned, data=test)
save_model(tuned, 'regressor')

from pycaret.time_series import *

data = get_data('airline')
ts = setup(data, fh=12, seasonal_period=12)
best = compare_models()
model = create_model('arima')
predictions = predict_model(model, fh=24)