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

进阶实现（TensorFlow/PyTorch）

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import torch
import torch.nn as nn
import torch.optim as optim

# TensorFlow 实现
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 实现
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]
        X = pd.DataFrame(self.imputer.fit_transform(X.select_dtypes(include=[np.number])), columns=X.select_dtypes(include=[np.number]).columns)
        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, confusion_matrix, classification_report, mean_squared_error, mean_absolute_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)
        }

实践应用指南

应用场景分析

最佳实践分享

1. 代码规范：使用类型注解，编写文档字符串，遵循 PEP8 规范，添加单元测试。
2. 实验管理：使用版本控制，记录实验参数，保存模型检查点，可视化训练过程。

案例分析

成功案例：房价预测模型

解决方案

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error
import matplotlib.pyplot as plt

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

实施效果

常见问题解答

Q1：如何选择合适的模型？

Q2：如何处理数据不平衡？

from imblearn.over_sampling import SMOTE
from imblearn.under_sampling import RandomUnderSampler
from sklearn.utils.class_weight import compute_class_weight

# 方法 1：过采样
smote = SMOTE(random_state=42)
X_resampled, y_resampled = smote.fit_resample(X, y)

# 方法 2：欠采样
undersampler = RandomUnderSampler(random_state=42)
X_resampled, y_resampled = undersampler.fit_resample(X, y)

# 方法 3：类别权重
class_weights = compute_class_weight('balanced', classes=np.unique(y), y=y)

总结

本文介绍了 AI 模型调优中的贝叶斯优化方法，重点讲解 Optuna 库的应用。内容涵盖核心概念、技术原理、数据处理流程、模型评估方法及实战案例。通过 Python 代码示例展示从数据预处理到模型训练优化的完整流程，包括 TensorFlow 和 PyTorch 的实现对比。文章分析常见应用场景、最佳实践及未来趋势，旨在帮助开发者提升模型性能与效率。