AI 调参技巧：贝叶斯优化 Optuna

AI 调参技巧：贝叶斯优化 Optuna | 极客日志

维度	说明	重要程度
理论基础	数学原理与算法推导	⭐⭐⭐⭐⭐
代码实现	Python 库的使用与编程	⭐⭐⭐⭐⭐
实践应用	解决实际问题的能力	⭐⭐⭐⭐
优化调参	提升模型性能的技巧	⭐⭐⭐⭐

概念	定义	与本章主题的关系
数据处理	数据的清洗、转换、特征工程	是模型训练的基础
模型构建	设计和实现 AI 模型	是核心任务
训练优化	调整参数提升性能	是关键环节

""" AI 调参技巧：贝叶斯优化 Optuna - 基础实现示例 """
import numpy as np
import pandas as pd
from typing import List, Dict, Optional, Tuple
import warnings
warnings.filterwarnings('ignore')

class CoreAIModel:
    """ AI 模型基础类 """
    def __init__(self, learning_rate: float = 0.01, epochs: int = 100, batch_size: int = 32):
        """ 初始化模型
        Args:
            learning_rate: 学习率
            epochs: 训练轮数
            batch_size: 批量大小
        """
        self.learning_rate = learning_rate
        self.epochs = epochs
        self.batch_size = batch_size
        self.weights = None
        self.bias = None
        self.loss_history = []

    def _initialize_parameters(self, n_features: int):
        """ 初始化模型参数 """
        np.random.seed(42)
        self.weights = np.random.randn(n_features) * 0.01
        self.bias = 0

    def _forward(self, X: np.ndarray) -> np.ndarray:
        """ 前向传播 """
        return np.dot(X, self.weights) + self.bias

    def _compute_loss(self, y_true: np.ndarray, y_pred: np.ndarray) -> float:
        """ 计算损失函数（均方误差） """
        return np.mean((y_true - y_pred)**2)

    def _backward(self, X: np.ndarray, y_true: np.ndarray, y_pred: np.ndarray):
        """ 反向传播计算梯度 """
        m = len(y_true)
        dw = -2/m * np.dot(X.T, (y_true - y_pred))
        db = -2/m * np.sum(y_true - y_pred)
        return dw, db

    def fit(self, X: np.ndarray, y: np.ndarray) -> 'CoreAIModel':
        """ 训练模型
        Args:
            X: 特征矩阵
            y: 目标变量
        Returns:
            self: 训练后的模型实例
        """
        n_samples, n_features = X.shape
        self._initialize_parameters(n_features)
        for epoch in range(self.epochs):
            indices = np.random.permutation(n_samples)
            X_shuffled = X[indices]
            y_shuffled = y[indices]
            for i in range(0, n_samples, self.batch_size):
                X_batch = X_shuffled[i:i+self.batch_size]
                y_batch = y_shuffled[i:i+self.batch_size]
                y_pred = self._forward(X_batch)
                loss = self._compute_loss(y_batch, y_pred)
                dw, db = self._backward(X_batch, y_batch, y_pred)
                self.weights -= self.learning_rate * dw
                self.bias -= self.learning_rate * db
                if (epoch + 1) % 10 == 0:
                    y_pred_full = self._forward(X)
                    loss = self._compute_loss(y, y_pred_full)
                    self.loss_history.append(loss)
                    print(f"Epoch {epoch+1}/{self.epochs}, Loss: {loss:.4f}")
        return self

    def predict(self, X: np.ndarray) -> np.ndarray:
        """ 预测
        Args:
            X: 特征矩阵
        Returns:
            预测结果
        """
        return self._forward(X)

    def score(self, X: np.ndarray, y: np.ndarray) -> float:
        """ 计算 R²分数
        Args:
            X: 特征矩阵
            y: 真实值
        Returns:
            R²分数
        """
        y_pred = self.predict(X)
        ss_res = np.sum((y - y_pred)**2)
        ss_tot = np.sum((y - np.mean(y))**2)
        return 1 - (ss_res / ss_tot)

if __name__ == "__main__":
    np.random.seed(42)
    X = np.random.randn(1000, 5)
    true_weights = np.array([1.5, -2.0, 0.5, 1.0, -0.5])
    y = np.dot(X, true_weights) + np.random.randn(1000) * 0.1
    split = int(0.8 * len(X))
    X_train, X_test = X[:split], X[split:]
    y_train, y_test = y[:split], y[split:]
    model = CoreAIModel(learning_rate=0.01, epochs=100, batch_size=32)
    model.fit(X_train, y_train)
    train_score = model.score(X_train, y_train)
    test_score = model.score(X_test, y_test)
    print(f"\n训练集 R²: {train_score:.4f}")
    print(f"测试集 R²: {test_score:.4f}")

""" 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

# ============== TensorFlow 实现 ==============
class TensorFlowModel:
    """ TensorFlow 版本的模型实现 """
    def __init__(self, input_dim: int, hidden_units: List[int] = [64, 32]):
        """ 初始化 TensorFlow 模型
        Args:
            input_dim: 输入维度
            hidden_units: 隐藏层单元数列表
        """
        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):
    """ PyTorch 版本的模型实现 """
    def __init__(self, input_dim: int, hidden_units: List[int] = [64, 32]):
        """ 初始化 PyTorch 模型
        Args:
            input_dim: 输入维度
            hidden_units: 隐藏层单元数列表
        """
        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}, "
                      f"Train Loss: {train_losses[-1]:.4f}, "
                      f"Val Loss: {val_losses[-1]:.4f}")
        return train_losses, val_losses

if __name__ == "__main__":
    # TensorFlow 示例
    print("=== TensorFlow 实现 ===")
    tf_model = TensorFlowModel(input_dim=5)
    # tf_model.train(X_train, y_train, X_val, y_val)
    # PyTorch 示例
    print("\n=== PyTorch 实现 ===")
    torch_model = PyTorchModel(input_dim=5)
    print(torch_model)

""" 数据处理完整流程 """
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:
        """ 完整的数据处理流程
        Args:
            data: 原始数据
            target_col: 目标列名
            categorical_cols: 类别列名列表
            test_size: 测试集比例
        Returns:
            处理后的训练集和测试集
        """
        # 1. 分离特征和目标
        X = data.drop(columns=[target_col])
        y = data[target_col]
        # 2. 处理缺失值
        X = pd.DataFrame(
            self.imputer.fit_transform(X.select_dtypes(include=[np.number])),
            columns=X.select_dtypes(include=[np.number]).columns
        )
        # 3. 编码类别特征
        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
        # 4. 标准化
        X_scaled = self.scaler.fit_transform(X)
        # 5. 划分数据集
        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

if __name__ == "__main__":
    data = pd.DataFrame({
        'feature1': np.random.randn(1000),
        'feature2': np.random.randn(1000),
        'feature3': np.random.choice(['A', 'B', 'C'], 1000),
        'target': np.random.randn(1000)
    })
    processor = DataProcessor()
    X_train, X_test, y_train, y_test = processor.process(
        data, target_col='target', categorical_cols=['feature3'])
    print(f"训练集形状：{X_train.shape}")
    print(f"测试集形状：{X_test.shape}")

""" 模型评估工具 """
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
import numpy as np

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

if __name__ == "__main__":
    # 分类评估示例
    y_true_cls = [0, 1, 0, 1, 0, 1, 0, 0, 1, 1]
    y_pred_cls = [0, 1, 0, 0, 0, 1, 1, 0, 1, 1]
    cls_metrics = ModelEvaluator.evaluate_classification(y_true_cls, y_pred_cls)
    print("分类指标:", cls_metrics)
    # 回归评估示例
    y_true_reg = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
    y_pred_reg = np.array([1.1, 1.9, 3.2, 3.8, 5.1])
    reg_metrics = ModelEvaluator.evaluate_regression(y_true_reg, y_pred_reg)
    print("回归指标:", reg_metrics)

# 数据分析完整流程示例
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score

def analyze_dataset(data_path: str):
    """ 完整的数据分析流程 """
    data = pd.read_csv(data_path)
    print("数据形状:", data.shape)
    print("\n数据概览:")
    print(data.head())
    print("\n数据类型:")
    print(data.dtypes)
    print("\n缺失值统计:")
    print(data.isnull().sum())
    print("\n描述性统计:")
    print(data.describe())
    numeric_cols = data.select_dtypes(include=[np.number]).columns
    fig, axes = plt.subplots(2, 2, figsize=(12, 10))
    for i, col in enumerate(numeric_cols[:4]):
        ax = axes[i // 2, i % 2]
        data[col].hist(ax=ax, bins=30, edgecolor='black')
        ax.set_title(f'{col}分布')
        ax.set_xlabel(col)
        ax.set_ylabel('频数')
    plt.tight_layout()
    plt.show()
    plt.figure(figsize=(10, 8))
    correlation = data[numeric_cols].corr()
    sns.heatmap(correlation, annot=True, cmap='coolwarm', center=0)
    plt.title('特征相关性热力图')
    plt.show()
    return data

应用领域	具体用途	推荐算法
分类问题	预测离散标签	随机森林、XGBoost
回归问题	预测连续值	线性回归、神经网络
聚类问题	数据分组	K-Means、DBSCAN
降维问题	特征压缩	PCA、t-SNE

# 创建虚拟环境
conda create -n ai_env python=3.9
conda activate ai_env
# 安装核心库
pip install numpy pandas matplotlib seaborn
pip install scikit-learn tensorflow torch
pip install jupyter notebook
# 验证安装
python -c "import tensorflow as tf; print(tf.__version__)"
python -c "import torch; print(torch.__version__)"

project/
├── data/          # 数据目录
│   ├── raw/       # 原始数据
│   ├── processed/ # 处理后数据
│   └── external/  # 外部数据
├── notebooks/     # Jupyter 笔记本
│   └── exploration.ipynb
├── src/           # 源代码
│   ├── data/      # 数据处理
│   ├── features/  # 特征工程
│   ├── models/    # 模型定义
│   └── utils/     # 工具函数
├── tests/         # 测试代码
├── configs/       # 配置文件
├── requirements.txt # 依赖列表
└── README.md      # 项目说明

阶段	任务	输出
数据准备	收集、清洗、划分	干净的数据集
特征工程	提取、选择、转换	特征矩阵
模型选择	算法对比、实验	最优模型
训练优化	调参、验证	训练好的模型
部署上线	打包、服务化	API 接口

""" 房价预测完整案例 """
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.ensemble import RandomForestRegressor, 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()

if __name__ == "__main__":
    pass

指标	数值
RMSE	25000
MAE	18000
R²	0.89

数据量	推荐模型	原因
小样本	传统 ML	不易过拟合
中等样本	集成学习	性能稳定
大样本	深度学习	潜力更大

# 处理数据不平衡的方法
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)

趋势	描述	预计时间
AutoML	自动化机器学习	已实现
大模型	预训练模型微调	主流趋势
多模态	图文音视频融合	快速发展
边缘 AI	端侧部署	持续推进

阶段	学习重点	时间投入
入门期	Python 基础、ML 概念	2-3 个月
进阶期	深度学习、项目实战	3-6 个月
专业期	领域深耕、论文复现	6-12 个月
专家期	创新研究、团队领导	1 年以上

AI 调参技巧：贝叶斯优化 Optuna

AI 调参技巧：贝叶斯优化 Optuna

一、引言

1.1 背景与意义

1.2 内容概览

二、核心概念解析

2.1 基本定义

2.2 关键术语解释

2.3 与相关概念的关系

三、技术原理深入

3.1 核心算法原理

3.2 数据处理流程

3.3 模型评估方法

四、实践应用指南

4.1 应用场景分析

4.2 实施步骤详解

4.3 最佳实践分享

五、案例分析

5.1 成功案例

5.2 失败教训

六、常见问题解答

6.1 技术问题

6.2 应用问题

七、未来发展趋势

7.1 技术趋势

7.2 应用趋势

7.3 职业发展

八、本章小结

8.1 核心要点回顾

8.2 学习建议

8.3 后续章节预告

更多推荐文章

相关免费在线工具

AI 调参技巧：贝叶斯优化 Optuna

AI 调参技巧：贝叶斯优化 Optuna

一、引言

1.1 背景与意义

1.2 内容概览

二、核心概念解析

2.1 基本定义

2.2 关键术语解释

2.3 与相关概念的关系

三、技术原理深入

3.1 核心算法原理

3.2 数据处理流程

3.3 模型评估方法

四、实践应用指南

4.1 应用场景分析

4.2 实施步骤详解

4.3 最佳实践分享

五、案例分析

5.1 成功案例

5.2 失败教训

六、常见问题解答

6.1 技术问题

6.2 应用问题

七、未来发展趋势

7.1 技术趋势

7.2 应用趋势

7.3 职业发展

八、本章小结

8.1 核心要点回顾

8.2 学习建议

8.3 后续章节预告

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具