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

技术二：进阶实现

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

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)

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

3.2 数据处理流程

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

3.3 模型评估方法

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)}

    @staticmethod
    def plot_confusion_matrix(y_true, y_pred, labels=None):
        cm = confusion_matrix(y_true, y_pred)
        plt.figure(figsize=(8, 6))
        sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=labels, yticklabels=labels)
        plt.title('混淆矩阵')
        plt.xlabel('预测值')
        plt.ylabel('真实值')
        plt.show()

    @staticmethod
    def plot_learning_curve(train_losses, val_losses):
        plt.figure(figsize=(10, 6))
        plt.plot(train_losses, label='训练损失')
        plt.plot(val_losses, label='验证损失')
        plt.xlabel('Epoch')
        plt.ylabel('Loss')
        plt.title('学习曲线')
        plt.legend()
        plt.grid(True)
        plt.show()

四、实践应用指南

4.1 应用场景分析

• 分类问题：随机森林、XGBoost
• 回归问题：线性回归、神经网络
• 聚类问题：K-Means、DBSCAN
• 降维问题：PCA、t-SNE

4.2 实施步骤详解

步骤一：环境准备

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

步骤二：项目结构

project/
├── data/
│   ├── raw/
│   ├── processed/
│   └── external/
├── notebooks/
├── src/
│   ├── data/
│   ├── features/
│   ├── models/
│   └── utils/
├── tests/
├── configs/
├── requirements.txt
└── README.md

五、案例分析

5.1 成功案例：房价预测模型

使用机器学习方法预测房屋价格，包含数据预处理、特征工程、模型训练完整流程。

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

    def plot_predictions(self, y_test, y_pred):
        plt.figure(figsize=(10, 6))
        plt.scatter(y_test, y_pred, alpha=0.5)
        plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--')
        plt.xlabel('真实价格')
        plt.ylabel('预测价格')
        plt.title('房价预测结果')
        plt.show()

5.2 失败教训：过拟合问题

某模型在训练集表现优秀，但测试集效果很差。改进措施包括增加数据量、使用正则化、添加 Dropout、早停法。

六、常见问题解答

6.1 技术问题

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

• 小样本：传统 ML
• 中等样本：集成学习
• 大样本：深度学习

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

from imblearn.over_sampling import SMOTE
from imblearn.under_sampling import RandomUnderSampler
from sklearn.utils.class_weight import compute_class_weight
smote = SMOTE(random_state=42)
X_resampled, y_resampled = smote.fit_resample(X, y)

6.2 应用问题

Q3：如何提升模型性能？ 数据增强、特征工程、模型集成、超参数调优。

七、未来发展趋势

• AutoML：自动化机器学习
• 大模型：预训练模型微调
• 多模态：图文音视频融合
• 边缘 AI：端侧部署

八、本章小结

本章涵盖了 AI 调参的基本定义、技术原理、代码实现、实践应用及常见问题解答。通过理论与实践结合，帮助读者建立完整的知识体系。建议持续学习并加入社区交流。