machine-learning

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Machine Learning

机器学习

Part of Agent Skills™ by googleadsagent.ai™

属于 googleadsagent.ai™ 提供的 Agent Skills™ 的一部分

Description

描述

Machine Learning provides end-to-end ML pipeline construction with PyTorch and scikit-learn, covering model selection, training, evaluation, interpretability, hyperparameter tuning, and experiment tracking. The agent builds reproducible ML workflows that follow software engineering best practices: version-controlled experiments, deterministic training, and interpretable results.

The gap between a working notebook and a production ML pipeline is enormous. This skill bridges that gap by enforcing structured experiment management, proper train/validation/test splits, stratified cross-validation, learning curve analysis, and systematic hyperparameter optimization. The agent tracks every experiment with its configuration, metrics, and artifacts, making it possible to reproduce any result months later.

Model interpretability is treated as a first-class requirement, not an optional post-hoc analysis. Every model comes with SHAP values, feature importance rankings, and partial dependence plots that explain what the model learned and why it makes specific predictions. Black-box predictions without explanations are insufficient for scientific and business-critical applications.

Machine Learning 使用 PyTorch 和 scikit-learn 提供端到端的 ML 流水线构建能力，涵盖模型选择、训练、评估、可解释性、超参数调优和实验跟踪。Agent 构建符合软件工程最佳实践的可复现 ML 工作流，包括版本控制实验、确定性训练和可解释结果。

可运行的 Notebook 与生产级 ML 流水线之间存在巨大差距。该 skill 通过强制执行结构化实验管理、正确的训练/验证/测试集划分、分层交叉验证、学习曲线分析和系统化超参数优化来弥补这一差距。Agent 会记录每次实验的配置、指标和产物，确保数月后仍可复现任何结果。

模型可解释性被视为一项核心要求，而非可选的事后分析。每个模型都配有 SHAP 值、特征重要性排名和部分依赖图，用于解释模型学到了什么，以及它为何做出特定预测。对于科学和业务关键型应用而言，没有解释的黑盒预测是不够的。

Use When

适用场景

Building classification or regression models
Tuning hyperparameters systematically
Explaining model predictions with SHAP or feature importance
Setting up experiment tracking for ML projects
Evaluating model performance with proper cross-validation
Training PyTorch models with structured training loops

构建分类或回归模型
系统化调优超参数
使用 SHAP 或特征重要性解释模型预测
为 ML 项目搭建实验跟踪机制
使用正确的交叉验证评估模型性能
使用结构化训练循环训练 PyTorch 模型

How It Works

工作原理

mermaid

graph TD
    A[Dataset] --> B[Train/Val/Test Split]
    B --> C[Feature Engineering]
    C --> D[Model Selection]
    D --> E[Hyperparameter Tuning: Optuna]
    E --> F[Cross-Validation]
    F --> G[Best Model Training]
    G --> H[Evaluation on Test Set]
    H --> I[Interpretability: SHAP]
    I --> J[Experiment Logging]
    J --> K[Model Registry]

The pipeline enforces a strict separation between tuning (using validation data) and final evaluation (using held-out test data). The test set is touched exactly once, preventing information leakage from repeated evaluation.

mermaid

graph TD
    A[数据集] --> B[训练/验证/测试集划分]
    B --> C[特征工程]
    C --> D[模型选择]
    D --> E[超参数调优：Optuna]
    E --> F[交叉验证]
    F --> G[最佳模型训练]
    G --> H[在测试集上评估]
    H --> I[可解释性：SHAP]
    I --> J[实验日志记录]
    J --> K[模型注册表]

该流水线严格区分调优（使用验证数据）与最终评估（使用保留的测试数据）。测试集仅使用一次，从而防止重复评估造成信息泄漏。

Implementation

实现

python

import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset
from sklearn.model_selection import StratifiedKFold
from sklearn.metrics import classification_report, roc_auc_score
import optuna
import shap
import numpy as np

class Classifier(nn.Module):
    def __init__(self, input_dim: int, hidden_dim: int, dropout: float):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.ReLU(),
            nn.Dropout(dropout),
            nn.Linear(hidden_dim, hidden_dim // 2),
            nn.ReLU(),
            nn.Dropout(dropout),
            nn.Linear(hidden_dim // 2, 1),
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        return self.net(x)

def train_epoch(model, loader, optimizer, criterion, device):
    model.train()
    total_loss = 0
    for X_batch, y_batch in loader:
        X_batch, y_batch = X_batch.to(device), y_batch.to(device)
        optimizer.zero_grad()
        pred = model(X_batch).squeeze()
        loss = criterion(pred, y_batch.float())
        loss.backward()
        optimizer.step()
        total_loss += loss.item() * len(X_batch)
    return total_loss / len(loader.dataset)

def hyperparameter_search(X: np.ndarray, y: np.ndarray, n_trials: int = 50) -> dict:
    def objective(trial):
        hidden = trial.suggest_int("hidden_dim", 32, 256)
        lr = trial.suggest_float("lr", 1e-4, 1e-2, log=True)
        dropout = trial.suggest_float("dropout", 0.1, 0.5)

        skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
        scores = []
        for train_idx, val_idx in skf.split(X, y):
            model = Classifier(X.shape[1], hidden, dropout)
            optimizer = torch.optim.Adam(model.parameters(), lr=lr)
            criterion = nn.BCEWithLogitsLoss()

            train_ds = TensorDataset(torch.tensor(X[train_idx], dtype=torch.float32),
                                     torch.tensor(y[train_idx], dtype=torch.float32))
            loader = DataLoader(train_ds, batch_size=64, shuffle=True)

            for _ in range(20):
                train_epoch(model, loader, optimizer, criterion, "cpu")

            model.eval()
            with torch.no_grad():
                val_pred = model(torch.tensor(X[val_idx], dtype=torch.float32)).squeeze()
            scores.append(roc_auc_score(y[val_idx], val_pred.numpy()))

        return np.mean(scores)

    study = optuna.create_study(direction="maximize")
    study.optimize(objective, n_trials=n_trials)
    return study.best_params

def explain_model(model, X_sample: np.ndarray, feature_names: list[str]):
    model.eval()
    explainer = shap.DeepExplainer(model, torch.tensor(X_sample[:100], dtype=torch.float32))
    shap_values = explainer.shap_values(torch.tensor(X_sample, dtype=torch.float32))
    shap.summary_plot(shap_values, X_sample, feature_names=feature_names, show=False)