AI 调参实战：贝叶斯优化与 Optuna 应用

进阶框架实现

实际项目中，我们通常使用 TensorFlow 或 PyTorch 来构建更复杂的网络结构。以下是两种主流框架的实现对比。

TensorFlow 版本

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

class TensorFlowModel:
    def __init__(self, input_dim: int, hidden_units: List[int] = [64, 32]):
        self.model = self._build_model(input_dim, hidden_units)

    def _build_model(self, input_dim: int, hidden_units: List[int]) -> keras.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']
        )
        return model

    def train(self, X_train, y_train, X_val, y_val, epochs=100, batch_size=32):
        history = self.model.fit(
            X_train, y_train,
            validation_data=(X_val, y_val),
            epochs=epochs,
            batch_size=batch_size,
            verbose=1
        )
        return history

    def predict(self, X):
        return self.model.predict(X)

PyTorch 版本

import torch
import torch.nn as nn
import torch.optim as optim

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)

    def train_model(self, train_loader, val_loader, epochs=100, lr=0.001):
        criterion = nn.MSELoss()
        optimizer = optim.Adam(self.parameters(), lr=lr)
        train_losses, val_losses = [], []
        
        for epoch in range(epochs):
            self.train()
            train_loss = 0.0
            for X_batch, y_batch in train_loader:
                optimizer.zero_grad()
                outputs = self(X_batch)
                loss = criterion(outputs, y_batch)
                loss.backward()
                optimizer.step()
                train_loss += loss.item()
            
            self.eval()
            val_loss = 0.0
            with torch.no_grad():
                for X_batch, y_batch in val_loader:
                    outputs = self(X_batch)
                    loss = criterion(outputs, y_batch)
                    val_loss += loss.item()
            
            train_losses.append(train_loss / len(train_loader))
            val_losses.append(val_loss / len(val_loader))
            
            if (epoch + 1) % 10 == 0:
                print(f"Epoch {epoch+1}/{epochs}, Train Loss: {train_losses[-1]:.4f}, Val Loss: {val_losses[-1]:.4f}")
        return train_losses, val_losses

数据处理与评估

数据质量直接决定了模型的天花板。一个标准的数据处理流程应包含缺失值填充、类别编码、标准化以及数据集划分。

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] = pd.DataFrame(
            self.imputer.fit_transform(X[numeric_cols]),
            columns=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

评估模型时，除了查看准确率，还应关注混淆矩阵、学习曲线以及具体的回归指标（RMSE, MAE, R²）。这有助于判断模型是否存在过拟合或欠拟合现象。

实践应用指南

环境准备

搭建稳定的开发环境是第一步。推荐使用 Conda 管理虚拟环境，避免依赖冲突。

conda create -n ai_env python=3.9
conda activate ai_env
pip install numpy pandas matplotlib seaborn scikit-learn tensorflow torch jupyter notebook

安装完成后，建议通过 import 命令验证各库版本是否正常。

项目结构规范

良好的目录结构能提升代码可维护性。推荐采用以下标准布局：

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

典型案例分析：房价预测

以房价预测为例，我们可以利用 Pipeline 将预处理与模型训练串联起来，减少数据泄露风险。

from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.metrics import mean_squared_error, r2_score
import numpy as np

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': np.mean(np.abs(y_test - y_pred)),
            'R2': r2_score(y_test, y_pred)
        }
        return metrics, y_pred

常见问题与最佳实践

Q1：如何选择模型？ 小样本场景下，传统机器学习（如随机森林）往往比深度学习更稳健；大样本则可以考虑神经网络挖掘非线性关系。

Q2：如何处理数据不平衡？ 可以使用 SMOTE 进行过采样，或者在损失函数中引入类别权重。例如：

from imblearn.over_sampling import SMOTE
smote = SMOTE(random_state=42)
X_resampled, y_resampled = smote.fit_resample(X, y)

Q3：如何避免过拟合？ 增加数据量、使用正则化、添加 Dropout 层以及早停法都是有效的改进措施。同时，确保验证集与测试集的分布一致至关重要。

总结与展望

掌握超参数调优不仅需要了解算法原理，更要具备工程落地的能力。随着 AutoML 和大模型技术的发展，未来的趋势将更多集中在预训练模型微调与多模态融合上。对于开发者而言，保持持续学习，结合理论与实践，才能在 AI 领域走得更远。