AI 模型调优实战：Python 核心技术与最佳实践

2. 进阶框架实现

实际项目中，我们更多使用 TensorFlow 或 PyTorch。它们提供了自动微分和高效的 GPU 加速。以下是两种框架的基础结构对比。

# TensorFlow 实现示例
tensorflow_model = ...
# 构建模型架构
inputs = keras.Input(shape=(input_dim,))
x = inputs
for units in hidden_units:
    x = layers.Dense(units, activation='relu')(x)
    x = layers.BatchNormalization()(x)
    x = layers.Dropout(0.2)(x)
outputs = layers.Dense(1)(x)
model = keras.Model(inputs=inputs, outputs=outputs)
model.compile(optimizer=keras.optimizers.Adam(learning_rate=0.001), loss='mse', metrics=['mae'])

# PyTorch 实现示例
class PyTorchModel(nn.Module):
    def __init__(self, input_dim: int, hidden_units: List[int] = [64, 32]):
        super(PyTorchModel, self).__init__()
        layers_list = []
        prev_units = input_dim
        for units in hidden_units:
            layers_list.append(nn.Linear(prev_units, units))
            layers_list.append(nn.ReLU())
            layers_list.append(nn.BatchNorm1d(units))
            layers_list.append(nn.Dropout(0.2))
            prev_units = units
        layers_list.append(nn.Linear(prev_units, 1))
        self.network = nn.Sequential(*layers_list)

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

3. 数据处理流水线

数据质量直接决定模型上限。一个健壮的 DataProcessor 应包含缺失值处理、编码和标准化。

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.impute import SimpleImputer
from typing import List, Tuple

class DataProcessor:
    def __init__(self):
        self.scaler = StandardScaler()
        self.label_encoders = {}
        self.imputer = SimpleImputer(strategy='mean')

    def process(self, data: pd.DataFrame, target_col: str, categorical_cols: List[str] = None, test_size: float = 0.2) -> Tuple:
        X = data.drop(columns=[target_col])
        y = data[target_col]

        # 处理缺失值
        numeric_cols = X.select_dtypes(include=[np.number]).columns
        X[numeric_cols] = self.imputer.fit_transform(X[numeric_cols])

        # 编码类别特征
        if categorical_cols:
            for col in categorical_cols:
                if col in X.columns:
                    le = LabelEncoder()
                    X[col] = le.fit_transform(X[col].astype(str))
                    self.label_encoders[col] = le

        # 标准化
        X_scaled = self.scaler.fit_transform(X)

        # 划分数据集
        X_train, X_test, y_train, y_test = train_test_split(
            X_scaled, y, test_size=test_size, random_state=42)
        return X_train, X_test, y_train, y_test

模型评估与实战案例

评估工具

统一的评估接口能让实验对比更公平。我们可以封装常用的分类和回归指标。

from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score, mean_squared_error, r2_score
import matplotlib.pyplot as plt
import seaborn as sns

class ModelEvaluator:
    @staticmethod
    def evaluate_classification(y_true, y_pred, y_prob=None):
        metrics = {
            'accuracy': accuracy_score(y_true, y_pred),
            'precision': precision_score(y_true, y_pred, average='weighted'),
            'recall': recall_score(y_true, y_pred, average='weighted'),
            'f1': f1_score(y_true, y_pred, average='weighted')
        }
        if y_prob is not None:
            metrics['roc_auc'] = roc_auc_score(y_true, y_prob, multi_class='ovr')
        return metrics

    @staticmethod
    def evaluate_regression(y_true, y_pred):
        return {
            'mse': mean_squared_error(y_true, y_pred),
            'rmse': np.sqrt(mean_squared_error(y_true, y_pred)),
            'mae': mean_absolute_error(y_true, y_pred),
            'r2': r2_score(y_true, y_pred)
        }

房价预测案例

以房价预测为例，展示完整的 Pipeline 构建。这里使用了 ColumnTransformer 来处理混合类型特征，并结合 GradientBoostingRegressor 进行训练。

from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.preprocessing import OneHotEncoder

class HousePricePredictor:
    def __init__(self):
        self.model = None
        self.preprocessor = None

    def prepare_data(self, data: pd.DataFrame, target_col: str):
        X = data.drop(columns=[target_col])
        y = data[target_col]
        
        numeric_features = X.select_dtypes(include=[np.number]).columns.tolist()
        categorical_features = X.select_dtypes(exclude=[np.number]).columns.tolist()

        self.preprocessor = ColumnTransformer(
            transformers=[
                ('num', StandardScaler(), numeric_features),
                ('cat', OneHotEncoder(handle_unknown='ignore'), categorical_features)
            ])
        return train_test_split(X, y, test_size=0.2, random_state=42)

    def train(self, X_train, y_train):
        self.model = Pipeline([
            ('preprocessor', self.preprocessor),
            ('regressor', GradientBoostingRegressor(
                n_estimators=200, learning_rate=0.1, max_depth=5, random_state=42))
        ])
        self.model.fit(X_train, y_train)
        return self

    def evaluate(self, X_test, y_test):
        y_pred = self.model.predict(X_test)
        metrics = {
            'RMSE': np.sqrt(mean_squared_error(y_test, y_pred)),
            'MAE': mean_absolute_error(y_test, y_pred),
            'R2': r2_score(y_test, y_pred)
        }
        return metrics, y_pred

最佳实践与建议

1. 环境与管理

建议采用标准的目录结构管理项目，便于协作和维护。

project/
├── data/          # 数据目录
│   ├── raw/       # 原始数据
│   └── processed/ # 处理后数据
├── notebooks/     # 探索性分析
├── src/           # 源代码
│   ├── models/    # 模型定义
│   └── utils/     # 工具函数
├── tests/         # 测试代码
└── requirements.txt

2. 常见问题排查

• 过拟合：如果训练集表现好但测试集差，尝试增加正则化、Dropout 或早停法。
• 数据不平衡：使用 SMOTE 进行过采样，或调整类别权重。
• 模型选择：小样本用传统 ML，中等样本用集成学习，大样本考虑深度学习。

3. 持续优化

调优不是一蹴而就的。建议记录每次实验的参数和结果，利用版本控制追踪变化。随着技术发展，AutoML 和大模型微调将成为主流趋势，保持对新技术的关注同样重要。

通过上述实践，你可以建立起一套完整的模型调优工作流。记住，最好的模型往往来自对数据的深刻理解和对细节的反复打磨。