Scikit-learn 1.8 完全指南：GPU 加速、免GIL多线程与七大新特性实战

import os
os.environ["SCIPY_ARRAY_API"] = "1"

import cupy
from sklearn.datasets import make_classification
from sklearn import config_context
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis

# 生成示例数据
X_np, y_np = make_classification(
    n_samples=50000, n_features=200, random_state=42
)

# 将数据转移到 GPU
X_cu = cupy.asarray(X_np)
y_cu = cupy.asarray(y_np)

# 启用 Array API 调度并训练模型
with config_context(array_api_dispatch=True):
    lda = LinearDiscriminantAnalysis(solver="svd")
    X_trans = lda.fit_transform(X_cu, y_cu)
    print(type(X_trans))  # <class 'cupy.ndarray'>

# 如需将结果转回 NumPy
X_trans_np = X_trans.get()

import os
os.environ["SCIPY_ARRAY_API"] = "1"

import torch
import numpy as np
from sklearn import config_context
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

# 准备 GPU 上的 PyTorch 张量
X_np = np.random.randn(10000, 50).astype(np.float32)
X_torch = torch.asarray(X_np, device="cuda", dtype=torch.float32)

with config_context(array_api_dispatch=True):
    # 标准化 + PCA 流水线，全部在 GPU 上执行
    scaler = StandardScaler()
    X_scaled = scaler.fit_transform(X_torch)

    pca = PCA(n_components=10, svd_solver="full")
    X_pca = pca.fit_transform(X_scaled)

    print(X_pca.device)  # cuda:0
    print(X_pca.shape)   # torch.Size([10000, 10])

import os
os.environ["SCIPY_ARRAY_API"] = "1"

import numpy as np
import torch
import sklearn
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import FunctionTransformer, StandardScaler
from sklearn.calibration import CalibratedClassifierCV
from sklearn.linear_model import RidgeClassifierCV
from sklearn.model_selection import cross_validate
from sklearn.datasets import make_classification

X_np, y_np = make_classification(
    n_samples=20000, n_features=100, n_classes=3,
    n_informative=30, random_state=42
)

alphas = np.logspace(-3, 3, 20)

# 构建 GPU 加速流水线
gpu_pipeline = make_pipeline(
    StandardScaler(),
    FunctionTransformer(
        lambda x: torch.tensor(
            x if isinstance(x, np.ndarray) else x.numpy(),
            device="cuda", dtype=torch.float32
        )
    ),
    CalibratedClassifierCV(
        RidgeClassifierCV(alphas=alphas),
        method="temperature"
    ),
)

with sklearn.config_context(array_api_dispatch=True):
    results = cross_validate(gpu_pipeline, X_np, y_np, cv=5)
    print(f"平均准确率: {results['test_score'].mean():.4f}")

import joblib
from sklearn.datasets import make_classification
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV

X, y = make_classification(n_samples=5000, n_features=20, random_state=42)

param_grid = {
    "n_estimators": [50, 100, 200],
    "max_depth": [5, 10, 20, None],
    "min_samples_split": [2, 5, 10],
}

clf = RandomForestClassifier(random_state=42)
grid_search = GridSearchCV(
    clf, param_grid=param_grid, cv=5, n_jobs=4, scoring="accuracy"
)

# 使用线程后端，在自由线程 CPython 下可获得真正的并行加速
with joblib.parallel_config(backend="threading"):
    grid_search.fit(X, y)

print(f"最佳参数: {grid_search.best_params_}")
print(f"最佳准确率: {grid_search.best_score_:.4f}")

from sklearn.calibration import CalibratedClassifierCV, CalibrationDisplay
from sklearn.datasets import make_classification
from sklearn.naive_bayes import GaussianNB
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt

# 生成三分类数据集
X, y = make_classification(
    n_samples=5000, n_classes=3, n_features=20,
    n_informative=8, random_state=42
)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42
)

# 训练基础分类器
base_clf = GaussianNB().fit(X_train, y_train)

# Sigmoid 校准
sigmoid_clf = CalibratedClassifierCV(
    base_clf, method="sigmoid", ensemble=False
).fit(X_train, y_train)

# 温度缩放校准（1.8 新特性）
temp_clf = CalibratedClassifierCV(
    base_clf, method="temperature", ensemble=False
).fit(X_train, y_train)

# 绘制可靠性图
fig, axes = plt.subplots(figsize=(12, 4), ncols=3, sharey=True)
for i, c in enumerate(temp_clf.classes_):
    CalibrationDisplay.from_predictions(
        y_test == c, base_clf.predict_proba(X_test)[:, i],
        name="未校准", ax=axes[i], marker="s"
    )
    CalibrationDisplay.from_predictions(
        y_test == c, temp_clf.predict_proba(X_test)[:, i],
        name="温度缩放", ax=axes[i], marker="o"
    )
    CalibrationDisplay.from_predictions(
        y_test == c, sigmoid_clf.predict_proba(X_test)[:, i],
        name="Sigmoid", ax=axes[i], marker="v"
    )
    axes[i].set_title(f"类别 {c}")

fig.suptitle("各类别可靠性图对比")
plt.tight_layout()
plt.show()

import time
from sklearn.datasets import make_regression
from sklearn.linear_model import ElasticNetCV, LassoCV

# 生成高维回归数据
X, y = make_regression(
    n_samples=2000, n_features=10000, n_informative=50, random_state=0
)

# ElasticNetCV 性能测试
model_en = ElasticNetCV(cv=5)
tic = time.time()
model_en.fit(X, y)
elapsed_en = time.time() - tic
print(f"ElasticNetCV 拟合耗时: {elapsed_en:.1f} 秒")
print(f"非零系数数量: {(model_en.coef_ != 0).sum()}")

# LassoCV 性能测试
model_lasso = LassoCV(cv=5)
tic = time.time()
model_lasso.fit(X, y)
elapsed_lasso = time.time() - tic
print(f"LassoCV 拟合耗时: {elapsed_lasso:.1f} 秒")
print(f"非零系数数量: {(model_lasso.coef_ != 0).sum()}")

from sklearn.manifold import ClassicalMDS

cmds = ClassicalMDS(
    n_components=2,       # 目标维度
    metric="euclidean",   # 距离度量，也可设为 "precomputed"
    metric_params=None    # 传递给距离度量的额外参数
)

import matplotlib.pyplot as plt
from matplotlib import ticker
from sklearn import datasets, manifold

# 生成三维 S 曲线数据
n_samples = 1500
S_points, S_color = datasets.make_s_curve(n_samples, random_state=0)

# 使用 ClassicalMDS 降到二维
cmds = manifold.ClassicalMDS(n_components=2)
S_2d = cmds.fit_transform(S_points)

# 可视化
fig = plt.figure(figsize=(12, 5))

# 原始三维 S 曲线
ax1 = fig.add_subplot(1, 2, 1, projection="3d")
ax1.scatter(*S_points.T, c=S_color, s=30, alpha=0.8, cmap="Spectral")
ax1.set_title("原始三维 S 曲线", fontsize=14)
ax1.view_init(azim=-60, elev=9)

# ClassicalMDS 二维映射
ax2 = fig.add_subplot(1, 2, 2)
ax2.scatter(*S_2d.T, c=S_color, s=30, alpha=0.8, cmap="Spectral")
ax2.set_title("ClassicalMDS 二维投影", fontsize=14)

plt.tight_layout()
plt.show()

from sklearn.manifold import ClassicalMDS
from sklearn.metrics import pairwise_distances
from sklearn.datasets import load_digits

X, y = load_digits(return_X_y=True)
X = X[:300]  # 取前 300 个样本

# 计算余弦距离矩阵
dist_matrix = pairwise_distances(X, metric="cosine")

# 使用预计算距离矩阵进行降维
cmds = ClassicalMDS(n_components=2, metric="precomputed")
X_2d = cmds.fit_transform(dist_matrix)
print(f"降维结果形状: {X_2d.shape}")  # (300, 2)

import time
from sklearn.datasets import make_regression
from sklearn.tree import DecisionTreeRegressor

# 生成大规模数据
X, y = make_regression(n_samples=500_000, n_features=10, random_state=42)

# 使用优化后的 absolute_error 准则
tree = DecisionTreeRegressor(criterion="absolute_error", max_depth=10)

tic = time.time()
tree.fit(X, y)
elapsed = time.time() - tic

print(f"样本数量: 500,000")
print(f"训练耗时: {elapsed:.2f} 秒")
print(f"树的叶节点数: {tree.get_n_leaves()}")

from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler, PolynomialFeatures
from sklearn.model_selection import GridSearchCV

# 构建一个嵌套流水线
pipe = make_pipeline(
    StandardScaler(),
    PolynomialFeatures(degree=2, interaction_only=True),
    LogisticRegression(C=10, max_iter=1000, random_state=0)
)

# 包装在 GridSearchCV 中
param_grid = {"logisticregression__C": [0.1, 1, 10]}
grid = GridSearchCV(pipe, param_grid, cv=5)

# 在 Jupyter Notebook 中直接显示
# 将看到带有参数链接和工具提示的交互式 HTML 表示
grid

# 使用 pip 安装或升级
pip install --upgrade scikit-learn

# 使用 conda 安装或升级
conda install -c conda-forge scikit-learn

# 验证版本
python -c "import sklearn; print(sklearn.__version__)"
# 输出: 1.8.0

# 在自由线程 CPython 3.14 环境中安装
pip install scikit-learn
# scikit-learn 会自动提供免 GIL 的 wheel 包

# 安装 CuPy（根据 CUDA 版本选择）
pip install cupy-cuda12x

# 或安装 PyTorch（根据 CUDA 版本选择）
pip install torch --index-url https://download.pytorch.org/whl/cu121