AI 调参实战：网格搜索优化详解

技术二：进阶实现

""" AI 调参技巧：网格搜索优化 - 进阶实现示例 使用 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:
    """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)

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:
        """ 完整的数据处理流程
        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}")

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

四、实践应用指南

4.1 应用场景分析

以下是 AI 调参与网格搜索优化的主要应用场景：

场景一：数据分析与挖掘

# 数据分析完整流程示例
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):
    """完整的数据分析流程"""
    # 1. 加载数据
    data = pd.read_csv(data_path)
    print("数据形状:", data.shape)
    print("\n数据概览:")
    print(data.head())
    
    # 2. 数据基本信息
    print("\n数据类型:")
    print(data.dtypes)
    print("\n缺失值统计:")
    print(data.isnull().sum())
    
    # 3. 描述性统计
    print("\n描述性统计:")
    print(data.describe())
    
    # 4. 可视化分析
    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()
    
    # 5. 相关性分析
    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

场景二：模型训练与优化

4.2 实施步骤详解

步骤一：环境准备

# 创建虚拟环境
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      # 项目说明

步骤三：模型开发流程

4.3 最佳实践分享

最佳实践一：代码规范

1. 使用类型注解
2. 编写文档字符串
3. 遵循 PEP8 规范
4. 添加单元测试

最佳实践二：实验管理

• 使用版本控制
• 记录实验参数
• 保存模型检查点
• 可视化训练过程

五、案例分析

5.1 成功案例

案例一：房价预测模型

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

解决方案

""" 房价预测完整案例 """
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__":
    # 加载数据（示例）
    # data = pd.read_csv('house_prices.csv')
    # predictor = HousePricePredictor()
    # X_train, X_test, y_train, y_test = predictor.prepare_data(data, 'price')
    # predictor.train(X_train, y_train)
    # metrics, y_pred = predictor.evaluate(X_test, y_test)
    # print("评估指标:", metrics)
    pass

实施效果

5.2 失败教训

案例二：过拟合问题

问题分析 某模型在训练集表现优秀，但测试集效果很差：

1. 训练集准确率 99%
2. 测试集准确率仅 65%
3. 模型泛化能力差

改进措施

• 增加数据量
• 使用正则化
• 添加 Dropout
• 早停法

六、常见问题解答

6.1 技术问题

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)

6.2 应用问题

Q3：如何提升模型性能？

优化策略：

1. 数据增强
2. 特征工程
3. 模型集成
4. 超参数调优

Q4：如何避免常见错误？

注意事项：

• 数据泄露问题
• 评估方法正确
• 超参数合理
• 代码可复现