用Anaconda驯服AI开发流:从数据预处理到模型部署,全链路环境标准化实战
序言:AI开发的“环境地狱”与Anaconda的救赎
在人工智能项目开发中,最令人头疼的往往不是算法本身,而是环境管理。Python 版本冲突、CUDA 驱动不匹配、requirements.txt 依赖混乱,往往让项目在“环境地狱”中寸步难行。
Anaconda 不仅仅是一个 Python 发行版,它是一个环境隔离、包管理、工作流编排的全能平台。本文将带你穿越 AI 开发的完整生命周期,通过实战代码与架构设计,建立一套标准化的全链路解决方案。
第一章:地基——标准化环境治理与 Conda 深度实战
1.1 为什么传统 pip + venv 不足以支撑 AI 开发?
AI 开发不同于传统 Web 开发,它依赖于:
-
二进制依赖:如 CUDA Toolkit、cuDNN,这些不是 Python 包。
-
非 Python 库:如 HDF5、OpenCV 底层库、FFmpeg。
-
GPU 栈的复杂性:TensorFlow 2.x 与 PyTorch 对 CUDA 版本要求极其严苛。
Conda 的优势在于它是一个跨平台的包管理器,能够管理 Python 库、C 库、系统库,甚至环境变量。
1.2 实战:建立“黄金基准”环境
我们推荐 Mamba(C++ 重写的 Conda)作为加速器,速度提升数十倍。
步骤 1:安装 Miniforge(Mamba 集成版)
Miniforge 是社区维护的轻量级 Anaconda 替代品,天然支持 Mamba 且无需商业授权。
bash
# Linux/Mac 安装 wget https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-Linux-x86_64.sh bash Miniforge3-Linux-x86_64.sh # 验证安装 mamba --version
步骤 2:配置 Conda 源与性能优化
创建 .condarc 文件,配置国内镜像(以清华源为例)并开启 libmamba 求解器(这是 Conda 22.11+ 后的核心性能提升)。
yaml
# ~/.condarc channels: - https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/pytorch/ - https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/ - defaults show_channel_urls: true auto_activate_base: false solver: libmamba # 关键:启用 libmamba 求解器
步骤 3:构建“数据科学核心”环境
我们需要创建一个包含 Jupyter Lab、常用数据科学库的基准环境。
bash
# 创建名为 ds_core 的环境,指定 Python 3.10 mamba create -n ds_core python=3.10 -y # 激活环境 mamba activate ds_core # 安装核心库(使用 mamba 并行安装) mamba install jupyterlab numpy pandas scikit-learn matplotlib seaborn -y # 安装特定版本的 PyTorch(包含 CUDA 支持,需根据本地显卡驱动选择) # 假设 CUDA 11.8 mamba install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia -y # 或者安装 TensorFlow mamba install tensorflow=2.13 cudatoolkit=11.8 cudnn -c conda-forge -y
1.3 环境即代码:environment.yml 实战
为了让项目可复现,必须将环境配置写入版本控制。不同于 requirements.txt,environment.yml 可以锁定所有依赖(包括 pip 包)。
实战:编写环境文件
yaml
# environment.yml
name: ai_project_x
channels:
- pytorch
- nvidia
- conda-forge
- defaults
dependencies:
- python=3.10
- pip
- numpy=1.24.3
- pandas=2.0.3
- scikit-learn=1.3.0
- matplotlib=3.7.2
- jupyterlab=4.0
- pytorch=2.1.0
- torchvision=0.16.0
- torchaudio=2.1.0
- pytorch-cuda=11.8
- cudatoolkit=11.8
- pip:
- transformers==4.35.0 # HuggingFace 库
- datasets==2.14.0
- mlflow==2.6.0 # 实验跟踪
- optuna==3.3.0 # 超参优化
创建环境:
bash
mamba env create -f environment.yml
1.4 环境快照与迁移
当需要部署到服务器时,导出精确的依赖列表。
bash
# 导出完整环境(包含精确版本哈希) mamba env export > environment_full.yml # 仅导出显式安装的包(更适合跨平台) mamba env export --from-history > environment_history.yml
第二章:炼油——数据预处理的标准化工厂
数据预处理占 AI 项目 80% 的时间。标准化在于:不可变数据、可复现处理、自动化校验。
2.1 数据版本控制:DVC 与 数据仓库
数据不应存储在 Git 中。使用 DVC (Data Version Control) 配合 S3/OSS/本地存储。
初始化 DVC:
bash
mamba install dvc -c conda-forge git init dvc init dvc remote add -d myremote s3://mybucket/data
2.2 构建 Pipeline:基于 Scikit-learn 的标准化预处理类
将数据预处理抽象为“可序列化”的 Pipeline,确保训练和推理使用完全相同的逻辑。
实战:自定义 Transformer
python
# src/preprocessing/feature_engineering.py
import pandas as pd
import numpy as np
from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import ColumnTransformer
import joblib
class OutlierClipper(BaseEstimator, TransformerMixin):
"""基于IQR的异常值修剪器,防止极端值干扰模型"""
def __init__(self, cols=None, factor=1.5):
self.cols = cols
self.factor = factor
self.bounds_ = {}
def fit(self, X, y=None):
if self.cols is None:
self.cols = X.select_dtypes(include=[np.number]).columns.tolist()
for col in self.cols:
Q1 = X[col].quantile(0.25)
Q3 = X[col].quantile(0.75)
IQR = Q3 - Q1
lower = Q1 - self.factor * IQR
upper = Q3 + self.factor * IQR
self.bounds_[col] = (lower, upper)
return self
def transform(self, X):
X_copy = X.copy()
for col in self.cols:
lower, upper = self.bounds_[col]
X_copy[col] = X_copy[col].clip(lower, upper)
return X_copy
def build_preprocessing_pipeline(num_features, cat_features):
"""构建标准化的预处理流水线"""
numeric_transformer = Pipeline(steps=[
('clipper', OutlierClipper(cols=num_features)),
('scaler', StandardScaler())
])
categorical_transformer = Pipeline(steps=[
('onehot', OneHotEncoder(handle_unknown='ignore', sparse_output=False))
])
preprocessor = ColumnTransformer(
transformers=[
('num', numeric_transformer, num_features),
('cat', categorical_transformer, cat_features)
])
return preprocessor
# 使用示例
if __name__ == "__main__":
# 假设 raw_df 是原始数据
raw_df = pd.read_csv("data/raw/sales.csv")
num_cols = raw_df.select_dtypes(include=np.number).columns.tolist()
cat_cols = raw_df.select_dtypes(include='object').columns.tolist()
pipeline = build_preprocessing_pipeline(num_cols, cat_cols)
processed_data = pipeline.fit_transform(raw_df)
# 保存 pipeline 用于推理
joblib.dump(pipeline, 'models/artifacts/preprocessor.pkl')
print("预处理 Pipeline 已保存")
2.3 大规模数据处理:Dask 与 Modin
当数据量超过内存时,利用 Dask 或 Modin(基于 Ray)进行分布式处理,但依然保持 Pandas API。
python
# 在 Conda 环境中安装 dask
# mamba install dask distributed dask-ml
import dask.dataframe as dd
# 读取 100GB 的 CSV 文件
df = dd.read_csv('data/raw/large_dataset/*.csv')
# 执行复杂聚合,利用所有 CPU 核心
result = df.groupby('category')['value'].mean().compute()
# 转换为 pandas 以便后续 sklearn 处理(如果数据缩小了)
pandas_df = result.compute()
2.4 数据质量监控:Great Expectations
在数据进入模型前,强制执行数据契约。
初始化:
bash
# 在项目目录 great_expectations init
定义期望(Expectations):
python
# great_expectations/expectations/expect_column_values_not_null.py
from great_expectations.core.expectation_suite import ExpectationSuite
suite = ExpectationSuite(expectation_suite_name="raw_data_validation")
suite.add_expectation(
expectation_type="expect_column_values_to_not_be_null",
kwargs={"column": "user_id"}
)
suite.add_expectation(
expectation_type="expect_column_values_to_be_between",
kwargs={"column": "age", "min_value": 0, "max_value": 120}
)
suite.save()
在预处理脚本中集成验证:
python
import great_expectations as ge
# 验证 DataFrame
df_ge = ge.from_pandas(raw_df)
validation_result = df_ge.validate(expectation_suite=suite)
if not validation_result["success"]:
raise ValueError("数据质量检查失败!请检查原始数据")
else:
print("数据质量验证通过")
第三章:锻造——模型训练与实验追踪
3.1 MLflow:实验管理的标准答案
MLflow 是管理 ML 生命周期的开源平台。在 Anaconda 环境中,我们需要将 MLflow 集成到训练脚本中。
启动 MLflow Tracking Server:
bash
# 创建存储实验结果的目录 mkdir mlruns # 启动 UI 服务,默认端口 5000 mlflow ui --backend-store-uri sqlite:///mlflow.db
实战:集成 MLflow 到 PyTorch 训练脚本
python
# src/training/train.py
import mlflow
import mlflow.pytorch
from torch.utils.data import DataLoader
from model import MyNeuralNet
import torch
def main():
# 设置实验名称
mlflow.set_experiment("Customer_Churn_Prediction")
# 自动记录超参数和指标
with mlflow.start_run(run_name="baseline_run") as run:
# 记录超参数
mlflow.log_param("learning_rate", 0.001)
mlflow.log_param("batch_size", 64)
mlflow.log_param("optimizer", "Adam")
# 初始化模型
model = MyNeuralNet()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
# 训练循环(简化)
for epoch in range(10):
loss = train_one_epoch(model, optimizer, train_loader)
acc = evaluate(model, val_loader)
# 记录指标
mlflow.log_metric("train_loss", loss, step=epoch)
mlflow.log_metric("val_accuracy", acc, step=epoch)
# 记录模型(保存为 PyTorch 格式)
mlflow.pytorch.log_model(model, "model", registered_model_name="churn_model_v1")
# 记录额外文件(如预处理配置)
mlflow.log_artifact("models/artifacts/preprocessor.pkl")
if __name__ == "__main__":
main()
3.2 超参数调优:Optuna + MLflow 闭环
Optuna 是高效的超参数优化框架。
python
import optuna
from optuna.integration import MLflowCallback
def objective(trial):
# 建议超参数
lr = trial.suggest_float("lr", 1e-5, 1e-1, log=True)
batch_size = trial.suggest_categorical("batch_size", [32, 64, 128])
# 训练模型...
accuracy = train_and_eval(lr, batch_size)
return accuracy
# 创建 MLflow 回调,自动记录每次 trial 的结果
mlflow_callback = MLflowCallback(
tracking_uri="sqlite:///mlflow.db",
metric_name="accuracy",
)
study = optuna.create_study(direction="maximize")
study.optimize(objective, n_trials=50, callbacks=[mlflow_callback])
print("Best trial:", study.best_trial.params)
3.3 模型版本控制与注册
在 MLflow UI 中,我们可以将性能最好的模型从“实验”提升到“注册模型”。
注册模型脚本:
python
import mlflow
from mlflow.tracking import MlflowClient
client = MlflowClient()
# 获取最佳实验的 run_id (假设我们从 UI 中获取)
run_id = "a1b2c3d4e5f6g7h8"
model_uri = f"runs:/{run_id}/model"
# 注册模型
result = mlflow.register_model(model_uri, "CustomerChurnModel")
print(f"Registered model version: {result.version}")
# 添加描述和标签
client.update_registered_model(
name="CustomerChurnModel",
description="XGBoost based model for predicting churn, trained on 2024 data"
)
# 设置生产阶段
client.transition_model_version_stage(
name="CustomerChurnModel",
version=result.version,
stage="Production"
)
第四章:封装——模型部署的标准化容器
4.1 模型服务化:FastAPI 与 推理 Pipeline
将预处理和模型推理封装成一个 HTTP 服务。
实战:构建 FastAPI 推理服务
python
# src/serving/app.py
import joblib
import torch
import numpy as np
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import pandas as pd
app = FastAPI(title="Churn Prediction API")
# 加载预处理器和模型
preprocessor = joblib.load("models/artifacts/preprocessor.pkl")
model = torch.jit.load("models/artifacts/model_scripted.pt") # 或使用 MLflow 加载
model.eval()
class PredictionRequest(BaseModel):
data: list # 期望输入为 JSON 列表格式
class PredictionResponse(BaseModel):
predictions: list
probabilities: list
@app.post("/predict", response_model=PredictionResponse)
async def predict(request: PredictionRequest):
try:
# 转换为 DataFrame
df = pd.DataFrame(request.data)
# 1. 应用预处理 Pipeline
processed_features = preprocessor.transform(df)
# 2. 模型推理(假设是分类模型)
with torch.no_grad():
inputs = torch.tensor(processed_features, dtype=torch.float32)
outputs = model(inputs)
probs = torch.softmax(outputs, dim=1).numpy()
preds = np.argmax(probs, axis=1)
return PredictionResponse(
predictions=preds.tolist(),
probabilities=probs.tolist()
)
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))
@app.get("/health")
async def health():
return {"status": "ok"}
# 启动命令: uvicorn src.serving.app:app --host 0.0.0.0 --port 8000
4.2 模型优化:TorchScript 与 ONNX
为了在生产环境中获得更低延迟,需要将 PyTorch 模型转换为 TorchScript 或 ONNX。
TorchScript 转换(追踪法):
python
import torch
from model import MyNeuralNet
model = MyNeuralNet()
model.load_state_dict(torch.load("checkpoint.pth"))
model.eval()
# 创建示例输入(匹配预处理后的维度)
example_input = torch.randn(1, 128) # 假设 128 个特征
# 追踪模型
traced_script_module = torch.jit.trace(model, example_input)
traced_script_module.save("models/artifacts/model_scripted.pt")
ONNX 转换(跨平台兼容):
python
import torch.onnx
# 导出 ONNX
torch.onnx.export(
model,
example_input,
"models/artifacts/model.onnx",
export_params=True,
opset_version=14,
input_names=['input'],
output_names=['output'],
dynamic_axes={'input': {0: 'batch_size'}, 'output': {0: 'batch_size'}}
)
# 使用 ONNX Runtime 进行推理(通常比原生 PyTorch 快)
import onnxruntime as ort
ort_session = ort.InferenceSession("models/artifacts/model.onnx")
outputs = ort_session.run(None, {'input': processed_features.numpy()})
4.3 标准化部署:Docker + Conda 镜像
使用 Conda 构建 Docker 镜像,确保环境一致性。
Dockerfile 最佳实践:
dockerfile
# 使用 Miniconda 作为基础镜像
FROM continuumio/miniconda3:latest
# 设置工作目录
WORKDIR /app
# 复制环境文件
COPY environment.yml .
# 使用 Mamba 快速创建环境(利用 Docker 缓存)
RUN conda install mamba -n base -c conda-forge && \
mamba env create -f environment.yml && \
conda clean -afy
# 确保 bash 激活环境
SHELL ["conda", "run", "-n", "ai_project_x", "/bin/bash", "-c"]
# 复制代码
COPY ./src ./src
COPY ./models ./models
# 暴露端口
EXPOSE 8000
# 启动服务
CMD ["conda", "run", "--no-capture-output", "-n", "ai_project_x", "uvicorn", "src.serving.app:app", "--host", "0.0.0.0", "--port", "8000"]
构建与运行:
bash
docker build -t ai-churn-predictor . docker run -p 8000:8000 ai-churn-predictor
第五章:交付——CI/CD 与模型持续监控
5.1 基于 GitHub Actions 的 ML Pipeline
实现代码提交 -> 自动测试 -> 自动训练 -> 部署的自动化流程。
.github/workflows/ml_pipeline.yml 示例:
yaml
name: ML Training Pipeline
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
jobs:
test-and-train:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Setup Miniconda
uses: conda-incubator/setup-miniconda@v2
with:
environment-file: environment.yml
activate-environment: ai_project_x
auto-activate-base: false
- name: Lint with flake8
shell: bash -l {0}
run: |
conda install flake8
flake8 src --count --max-complexity=10 --statistics
- name: Test with pytest
shell: bash -l {0}
run: |
conda install pytest
pytest tests/
- name: Train Model
shell: bash -l {0}
run: |
python src/training/train.py --data-path data/processed
- name: Upload Model Artifact
uses: actions/upload-artifact@v3
with:
name: trained-model
path: models/
5.2 模型漂移监控:Evidently AI
在生产环境中,模型性能会随时间下降(概念漂移)。使用 Evidently 监控数据分布变化。
监控脚本:
python
import pandas as pd
from evidently.report import Report
from evidently.metrics import DataDriftTable
from evidently.metric_preset import DataDriftPreset
# 参考数据(训练时的数据)
reference = pd.read_csv("data/reference.csv")
# 当前生产数据(最近一周)
current = pd.read_csv("data/production/last_week.csv")
# 生成漂移报告
data_drift_report = Report(metrics=[
DataDriftPreset(),
])
data_drift_report.run(reference_data=reference, current_data=current)
data_drift_report.save_html("reports/data_drift_report.html")
# 如果检测到严重漂移,触发告警(例如发送 Slack 消息)
if data_drift_report.as_dict()["metrics"][0]["result"]["drift_by_columns"]["num_drifted_columns"] > 3:
send_alert("严重数据漂移检测,请考虑重新训练模型!")
5.3 自动重训练流水线
结合 Apache Airflow 或 Prefect,实现定时任务:当漂移达到阈值或定期(如每周)自动拉取新数据,重新运行训练流水线,并通过 MLflow 注册新模型,最后通过蓝绿部署更新生产服务。
第六章:最佳实践与避坑指南
6.1 Conda 环境管理黄金法则
-
不要使用
base环境:创建项目专属环境。 -
优先使用 Conda 包,其次 Pip:Conda 能处理二进制依赖,Pip 无法安装非 Python 库(如 cudatoolkit)。
-
显式指定 Python 版本:创建环境时一定要指定
python=3.x。 -
解决冲突:当
mamba install失败时,尝试逐层安装(先装框架,再装其他库),或者使用mamba update --all更新依赖图。
6.2 GPU 环境一致性
GPU 环境是最大痛点。
-
开发环境:本地通过 Conda 安装匹配的
cudatoolkit和pytorch-cuda。 -
生产环境:在 Docker 中使用 NVIDIA Container Toolkit。确保 Docker 镜像中的
libcudnn与驱动兼容。
bash
# 验证 Docker 中 GPU 是否可用 docker run --gpus all ai-churn-predictor nvidia-smi
6.3 安全性:保护模型与 API
-
API 密钥管理:使用环境变量或 HashiCorp Vault,绝对不要硬编码在代码中。
-
模型加密:对于商业模型,可以使用 PyArmor 混淆代码,或使用 TensorFlow 的加密签名机制。
结语:从混乱到秩序
本文从零开始,利用 Anaconda 生态构建了一套覆盖数据预处理、模型训练、实验追踪、部署上线、持续监控的标准化全链路解决方案。
通过这套体系,你不仅能告别“在我电脑上能跑”的尴尬,更能建立起可复现、可审计、可扩展的工程化 AI 开发流。AI 工程师的核心竞争力,正在于将“炼丹”转化为“炼钢”的能力。
后续行动建议:
-
将文中的
environment.yml和预处理 Pipeline 模板化,作为团队新项目的脚手架。 -
在本地搭建 MLflow 和 DVC 服务,实践版本控制。
-
尝试将 FastAPI 服务部署到云服务器或 Kubernetes 集群,完成真正的生产落地。
一、模板化项目脚手架:一键生成标准 AI 项目结构
1.1 推荐的项目目录结构
text
my_ai_project/ ├── .dvc/ # DVC 元数据 ├── .gitignore # 忽略 data/、models/、mlruns/ 等 ├── README.md ├── environment.yml # Conda 环境定义 ├── setup.py / pyproject.toml # 可选,用于安装自定义包 ├── config/ │ ├── __init__.py │ ├── params.yaml # 超参数配置(可选,便于 Hydra) ├── data/ │ ├── raw/ # 原始数据(不提交 Git,由 DVC 管理) │ ├── processed/ # 处理后数据(DVC 管理) │ ├── reference/ # 参考数据(如训练集分布) ├── notebooks/ # Jupyter 探索性分析 ├── src/ │ ├── __init__.py │ ├── preprocessing/ │ │ ├── __init__.py │ │ ├── pipeline.py # 预处理 Pipeline 模板 │ │ ├── transformers.py # 自定义 Transformer │ ├── training/ │ │ ├── __init__.py │ │ ├── train.py # 训练脚本,集成 MLflow │ │ ├── model.py # 模型定义 │ │ ├── utils.py # 辅助函数 │ ├── serving/ │ │ ├── __init__.py │ │ ├── app.py # FastAPI 应用 │ │ ├── schemas.py # Pydantic 模型 │ ├── evaluation/ │ │ ├── __init__.py │ │ ├── metrics.py # 自定义评估指标 │ │ ├── drift.py # 漂移检测脚本 ├── tests/ │ ├── test_preprocessing.py │ ├── test_model.py ├── scripts/ │ ├── download_data.py # 数据获取脚本 │ ├── run_pipeline.sh # 一键运行整个流程 ├── models/ │ ├── artifacts/ # 保存预处理器、模型文件 │ ├── mlflow/ # MLflow 本地存储(可选) ├── deployments/ │ ├── Dockerfile │ ├── k8s/ │ │ ├── deployment.yaml │ │ ├── service.yaml │ │ ├── ingress.yaml ├── .env.example # 环境变量示例 ├── dvc.lock ├── dvc.yaml # DVC pipeline 定义(可选)
1.2 environment.yml 模板(包含完整依赖)
yaml
name: ai_project_team
channels:
- pytorch
- nvidia
- conda-forge
- defaults
dependencies:
- python=3.10
- pip
# 基础科学计算
- numpy=1.24.3
- pandas=2.0.3
- scikit-learn=1.3.0
- matplotlib=3.7.2
- seaborn=0.12.2
# 深度学习框架(选其一,此处以 PyTorch 为例)
- pytorch=2.1.0
- torchvision=0.16.0
- torchaudio=0.16.0
- pytorch-cuda=11.8
- cudatoolkit=11.8
# 实验跟踪 & 版本控制
- mlflow=2.6.0
- dvc=3.30.0
- dvc-s3=3.30.0 # 若使用 S3 作为远程存储
# 超参数优化
- optuna=3.3.0
# 模型服务
- fastapi=0.104.1
- uvicorn=0.24.0
- pydantic=2.4.2
- python-multipart
# 数据验证 & 监控
- great-expectations=0.17.0
- evidently=0.4.0
# 其他工具
- jupyterlab=4.0.6
- pytest=7.4.0
- flake8=6.1.0
- black=23.11.0
- pip:
- datasets==2.14.0
- transformers==4.35.0
- hydra-core==1.3.2 # 配置管理
- pre-commit==3.5.0
1.3 预处理 Pipeline 模板(可复用基类 + 工厂函数)
将常用 Transformer 抽象为模块,便于新项目直接复制修改。
src/preprocessing/transformers.py
python
import pandas as pd
import numpy as np
from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
import joblib
class OutlierClipper(BaseEstimator, TransformerMixin):
"""基于 IQR 的异常值修剪"""
def __init__(self, cols=None, factor=1.5):
self.cols = cols
self.factor = factor
self.bounds_ = {}
def fit(self, X, y=None):
if self.cols is None:
self.cols = X.select_dtypes(include=[np.number]).columns.tolist()
for col in self.cols:
Q1 = X[col].quantile(0.25)
Q3 = X[col].quantile(0.75)
IQR = Q3 - Q1
lower = Q1 - self.factor * IQR
upper = Q3 + self.factor * IQR
self.bounds_[col] = (lower, upper)
return self
def transform(self, X):
X_copy = X.copy()
for col in self.cols:
lower, upper = self.bounds_[col]
X_copy[col] = X_copy[col].clip(lower, upper)
return X_copy
class ColumnDropper(BaseEstimator, TransformerMixin):
"""删除指定列"""
def __init__(self, cols_to_drop=None):
self.cols_to_drop = cols_to_drop
def fit(self, X, y=None):
return self
def transform(self, X):
if self.cols_to_drop:
return X.drop(columns=self.cols_to_drop, errors='ignore')
return X
class FeatureEngineer(BaseEstimator, TransformerMixin):
"""自定义特征工程,例如创建交互特征"""
def __init__(self, interactions=None):
self.interactions = interactions # 例如 [('col1', 'col2')]
def fit(self, X, y=None):
return self
def transform(self, X):
X_copy = X.copy()
if self.interactions:
for col1, col2 in self.interactions:
X_copy[f'{col1}_{col2}_interact'] = X_copy[col1] * X_copy[col2]
return X_copy
def build_preprocessing_pipeline(
num_features: list,
cat_features: list,
drop_features: list = None,
interactions: list = None,
outlier_factor: float = 1.5
) -> ColumnTransformer:
"""
构建标准化的预处理 Pipeline
Args:
num_features: 数值特征列名列表
cat_features: 类别特征列名列表
drop_features: 需要删除的列名列表
interactions: 交互特征列表,如 [('feat1', 'feat2')]
outlier_factor: 异常值修剪因子
Returns:
ColumnTransformer 对象
"""
# 可选:先删除无用列
pre_pipe = []
if drop_features:
pre_pipe.append(('drop', ColumnDropper(drop_features)))
# 数值特征流水线
numeric_transformer = Pipeline(steps=[
('clipper', OutlierClipper(cols=num_features, factor=outlier_factor)),
('scaler', StandardScaler())
])
# 类别特征流水线
categorical_transformer = Pipeline(steps=[
('onehot', OneHotEncoder(handle_unknown='ignore', sparse_output=False))
])
# 交互特征(需要在 OneHot 之前做?实际可在原始特征上做,但为了简单,在原始 df 上做)
# 注意:交互特征需要在删除列之前?这里简化,假设交互特征基于原始数值列
# 实际使用时可以先做交互再传入 pipeline
# 为简化,我们只在最终 ColumnTransformer 之外处理交互,或集成到自定义 Transformer 中。
# 更好的方式:将 FeatureEngineer 放入预处理流程中,但 ColumnTransformer 不支持跨列变换。
# 建议:在外部先用 FeatureEngineer 处理,再送入 ColumnTransformer。
# 构建 ColumnTransformer
preprocessor = ColumnTransformer(
transformers=[
('num', numeric_transformer, num_features),
('cat', categorical_transformer, cat_features)
],
remainder='drop' # 未指定的列丢弃
)
# 如果有交互特征,可以用 Pipeline 包装
if interactions:
# 将交互特征工程放在 ColumnTransformer 之前
full_pipeline = Pipeline(steps=[
('feat_eng', FeatureEngineer(interactions)),
('preprocessor', preprocessor)
])
return full_pipeline
else:
return preprocessor
src/preprocessing/pipeline.py(简化版,直接调用工厂函数)
python
from .transformers import build_preprocessing_pipeline
import joblib
def create_and_save_pipeline(data, num_cols, cat_cols, drop_cols=None, interactions=None, output_path='models/artifacts/preprocessor.pkl'):
pipeline = build_preprocessing_pipeline(num_cols, cat_cols, drop_cols, interactions)
pipeline.fit(data)
joblib.dump(pipeline, output_path)
print(f"Pipeline saved to {output_path}")
return pipeline
1.4 初始化新项目的脚本(Bash / Python)
创建一个 scripts/create_project.sh:
bash
#!/bin/bash
# 用法: ./create_project.sh my_new_project
PROJECT_NAME=$1
mkdir $PROJECT_NAME
cd $PROJECT_NAME
# 创建目录结构
mkdir -p data/{raw,processed,reference} notebooks src/{preprocessing,training,serving,evaluation} tests models/artifacts scripts deployments/k8s config
# 复制模板文件
cp ../path/to/template/environment.yml .
cp -r ../path/to/template/src/preprocessing/* src/preprocessing/
cp -r ../path/to/template/src/training/* src/training/
# ... 更多复制
# 初始化 Git
git init
git add .
git commit -m "Initial project scaffold"
# 初始化 DVC
dvc init
dvc remote add -d local /tmp/dvc_store # 或使用 S3
git add .dvc
git commit -m "Initialize DVC"
echo "Project $PROJECT_NAME created successfully!"
二、本地搭建 MLflow 和 DVC 服务,实践版本控制
2.1 安装并启动 MLflow Tracking Server
安装 MLflow(已包含在 environment.yml 中)
bash
conda activate ai_project_team pip install mlflow[extras] # 确保安装完整功能
启动本地 Tracking Server(使用 SQLite 作为后端存储)
bash
# 创建存储目录
mkdir -p ~/mlflow_data
cd ~/mlflow_data
mlflow server \
--backend-store-uri sqlite:///mlflow.db \
--default-artifact-root file:./artifacts \
--host 0.0.0.0 \
--port 5000
访问 http://localhost:5000 查看 UI。
可选:使用 PostgreSQL 生产级后端(需要安装 psycopg2)
bash
# 创建数据库(假设已有 PostgreSQL)
createdb mlflow_db
mlflow server \
--backend-store-uri postgresql://username:password@localhost/mlflow_db \
--default-artifact-root s3://my-mlflow-bucket/ \
--host 0.0.0.0 \
--port 5000
2.2 DVC 版本控制实践
初始化 DVC 仓库
bash
cd my_ai_project dvc init git add .dvc git commit -m "Initialize DVC"
添加远程存储(本地文件系统或 S3)
bash
# 本地存储(用于测试) dvc remote add -d local /tmp/dvc_cache # 或 S3 存储(需要配置 AWS 凭证) dvc remote add -d s3remote s3://my-dvc-bucket/data dvc remote modify s3remote endpointurl https://s3.amazonaws.com
数据版本控制流程
bash
# 将数据添加到 DVC 跟踪 dvc add data/raw/large_dataset.csv git add data/raw/large_dataset.csv.dvc .gitignore git commit -m "Track raw data with DVC" # 推送数据到远程存储 dvc push # 拉取数据(在其他机器上) dvc pull
DVC Pipeline 定义(dvc.yaml),实现自动化
yaml
stages:
preprocess:
cmd: python src/preprocessing/pipeline.py --input data/raw --output data/processed
deps:
- data/raw
- src/preprocessing/pipeline.py
outs:
- data/processed
metrics:
- metrics/preprocess_stats.json
train:
cmd: python src/training/train.py --data data/processed --model models/model.pkl
deps:
- data/processed
- src/training/train.py
outs:
- models/model.pkl
metrics:
- metrics/train_metrics.json
运行 dvc repro 即可一键重现整个流程。
2.3 集成 MLflow 与 DVC
在训练脚本中,MLflow 会自动记录实验参数、指标和模型。DVC 负责数据版本和 pipeline 版本。两者结合:
-
DVC 管理数据和代码版本,确保可复现性。
-
MLflow 管理实验元数据,便于对比和选择最佳模型。
示例:训练脚本中设置 MLflow Tracking URI
python
import mlflow
mlflow.set_tracking_uri("http://localhost:5000")
mlflow.set_experiment("my_experiment")
with mlflow.start_run():
# 记录参数
mlflow.log_params(params)
# 训练...
mlflow.log_metrics(metrics)
# 记录模型
mlflow.sklearn.log_model(model, "model")
三、部署 FastAPI 服务到云服务器或 Kubernetes
3.1 构建优化的 Docker 镜像
Dockerfile(基于 Miniconda,利用多阶段构建减小体积)
dockerfile
# 第一阶段:构建环境
FROM continuumio/miniconda3:latest as builder
WORKDIR /app
COPY environment.yml .
RUN conda install mamba -n base -c conda-forge && \
mamba env create -f environment.yml && \
conda clean -afy
# 第二阶段:运行时
FROM continuumio/miniconda3:latest
WORKDIR /app
COPY --from=builder /opt/conda /opt/conda
# 复制代码和模型
COPY src/serving/ ./src/serving/
COPY models/artifacts/ ./models/artifacts/
# 设置环境变量
ENV PYTHONPATH=/app
ENV MLFLOW_TRACKING_URI=http://mlflow-server:5000 # 可选
# 暴露端口
EXPOSE 8000
# 启动命令
CMD ["conda", "run", "--no-capture-output", "-n", "ai_project_team", "uvicorn", "src.serving.app:app", "--host", "0.0.0.0", "--port", "8000"]
构建镜像并推送到仓库
bash
docker build -t myregistry/ai-churn:latest . docker push myregistry/ai-churn:latest
3.2 部署到云服务器(单机 Docker)
在云服务器上(如 AWS EC2)
bash
# 拉取镜像 docker pull myregistry/ai-churn:latest # 运行容器,映射端口,并传递环境变量 docker run -d \ --name ai-service \ -p 80:8000 \ -e MLFLOW_TRACKING_URI=http://mlflow-server:5000 \ myregistry/ai-churn:latest
配置 Nginx 反向代理(可选)
nginx
server {
listen 80;
server_name api.example.com;
location / {
proxy_pass http://localhost:8000;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
}
}
3.3 部署到 Kubernetes 集群
编写 Deployment YAML (deployments/k8s/deployment.yaml)
yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: ai-churn-deployment
namespace: ai
spec:
replicas: 3
selector:
matchLabels:
app: ai-churn
template:
metadata:
labels:
app: ai-churn
spec:
containers:
- name: ai-churn
image: myregistry/ai-churn:latest
ports:
- containerPort: 8000
env:
- name: MLFLOW_TRACKING_URI
value: "http://mlflow-server:5000"
resources:
requests:
memory: "2Gi"
cpu: "1000m"
limits:
memory: "4Gi"
cpu: "2000m"
livenessProbe:
httpGet:
path: /health
port: 8000
initialDelaySeconds: 30
periodSeconds: 10
readinessProbe:
httpGet:
path: /health
port: 8000
initialDelaySeconds: 5
periodSeconds: 5
Service YAML (deployments/k8s/service.yaml)
yaml
apiVersion: v1
kind: Service
metadata:
name: ai-churn-service
namespace: ai
spec:
selector:
app: ai-churn
ports:
- protocol: TCP
port: 80
targetPort: 8000
type: LoadBalancer # 若云厂商支持,否则用 ClusterIP + Ingress
Ingress YAML (deployments/k8s/ingress.yaml)
yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: ai-churn-ingress
namespace: ai
annotations:
kubernetes.io/ingress.class: nginx
cert-manager.io/cluster-issuer: letsencrypt-prod
spec:
tls:
- hosts:
- api.example.com
secretName: ai-tls
rules:
- host: api.example.com
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: ai-churn-service
port:
number: 80
部署到 Kubernetes
bash
kubectl create namespace ai kubectl apply -f deployments/k8s/deployment.yaml kubectl apply -f deployments/k8s/service.yaml kubectl apply -f deployments/k8s/ingress.yaml
3.4 部署 MLflow 到 Kubernetes(可选)
为了方便生产环境跟踪实验,也可将 MLflow 部署到 K8s 中:
-
使用 PostgreSQL 作为后端存储。
-
使用 S3 兼容存储(如 MinIO)作为 artifact store。
-
通过 Service 暴露 UI。
简单示例(需提前准备好 PostgreSQL 和 MinIO)
yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: mlflow-server
spec:
replicas: 1
selector:
matchLabels:
app: mlflow-server
template:
metadata:
labels:
app: mlflow-server
spec:
containers:
- name: mlflow
image: ghcr.io/mlflow/mlflow:latest
args:
- "server"
- "--host=0.0.0.0"
- "--port=5000"
- "--backend-store-uri=postgresql://user:pass@postgres-service/mlflow"
- "--default-artifact-root=s3://mlflow-bucket/"
env:
- name: AWS_ACCESS_KEY_ID
valueFrom:
secretKeyRef:
name: minio-secret
key: access_key
- name: AWS_SECRET_ACCESS_KEY
valueFrom:
secretKeyRef:
name: minio-secret
key: secret_key
- name: MLFLOW_S3_ENDPOINT_URL
value: "http://minio-service:9000"
更多推荐
所有评论(0)