PythonAI算法
AI 调参技巧：网格搜索优化
AI 开发中的参数优化方法，重点讲解网格搜索（Grid Search）在模型调参中的应用。内容涵盖 Python 基础实现、TensorFlow/PyTorch 进阶方案、数据处理流程、模型评估指标及房价预测案例。通过代码示例展示了从环境搭建到模型部署的完整流程，旨在帮助开发者提升模型性能与泛化能力。
AI 开发中的参数优化方法，重点讲解网格搜索（Grid Search）在模型调参中的应用。内容涵盖 Python 基础实现、TensorFlow/PyTorch 进阶方案、数据处理流程、模型评估指标及房价预测案例。通过代码示例展示了从环境搭建到模型部署的完整流程，旨在帮助开发者提升模型性能与泛化能力。
在人工智能快速发展的今天，模型调参已成为提升性能的关键技能。Python 作为 AI 开发的主流语言，其丰富的生态系统和简洁的语法使其成为机器学习和深度学习的首选工具。
AI 调参与网格搜索优化涉及数据处理、模型构建、训练优化等关键环节。
| 维度 | 说明 | 重要程度 |
|---|---|---|
| 理论基础 | 数学原理与算法推导 | ⭐⭐⭐⭐⭐ |
| 代码实现 | Python 库的使用与编程 | ⭐⭐⭐⭐⭐ |
| 实践应用 | 解决实际问题的能力 | ⭐⭐⭐⭐ |
| 优化调参 | 提升模型性能的技巧 | ⭐⭐⭐⭐ |
"""
AI 调参技巧：网格搜索优化 - 基础实现示例
"""
import numpy as np
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):
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':
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:
return self._forward(X)
def score(self, X: np.ndarray, y: np.ndarray) -> float:
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 调参技巧：网格搜索优化 - 进阶实现示例
使用 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
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()
| 应用领域 | 具体用途 | 推荐算法 |
|---|---|---|
| 分类问题 | 预测离散标签 | 随机森林、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 scikit-learn tensorflow torch jupyter notebook
步骤二：项目结构
project/
├── data/ # 数据目录
│ ├── raw/ # 原始数据
│ └── processed/ # 处理后数据
├── notebooks/ # Jupyter 笔记本
├── src/ # 源代码
│ ├── data/ # 数据处理
│ ├── features/ # 特征工程
│ ├── models/ # 模型定义
│ └── utils/ # 工具函数
├── tests/ # 测试代码
├── configs/ # 配置文件
└── requirements.txt
解决方案
"""房价预测完整案例"""
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 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()
实施效果
| 指标 | 数值 |
|---|---|
| RMSE | 25000 |
| MAE | 18000 |
| R² | 0.89 |
问题分析 某模型在训练集表现优秀，但测试集效果很差（训练集准确率 99%，测试集 65%）。
改进措施
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)
| 趋势 | 描述 | 预计时间 |
|---|---|---|
| AutoML | 自动化机器学习 | 已实现 |
| 大模型 | 预训练模型微调 | 主流趋势 |
| 多模态 | 图文音视频融合 | 快速发展 |
| 边缘 AI | 端侧部署 | 持续推进 |
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
生成新的随机RSA私钥和公钥pem证书。 在线工具，RSA密钥对生成器在线工具，online
基于 Mermaid.js 实时预览流程图、时序图等图表，支持源码编辑与即时渲染。 在线工具，Mermaid 预览与可视化编辑在线工具，online
解析常见 curl 参数并生成 fetch、axios、PHP curl 或 Python requests 示例代码。 在线工具，curl 转代码在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online