数据工程终极设计模式——机器学习工程模式

引言

当我们谈到 machine learning 时，很自然会把注意力放在构建 models 上——调优 hyperparameters、选择 algorithms，以及优化 performance。然而，这只是真实旅程中的一小部分。实践中，真正的挑战通常在 model 开发完成之后才开始。一个在受控环境中表现良好的 model，部署后往往会因为 data pipelines 问题、input data 不一致、performance 随时间退化，或缺乏 monitoring 而失败。这些挑战不是 modeling 的失败，而是 engineering 的失败，而这正是 machine learning engineering 变得关键的地方。

Machine learning engineering 是一门将 prototypes 转化为 reliable、scalable 和 maintainable systems 的学科。它关注 machine learning solution 的完整 lifecycle，从 data ingestion 和 feature preparation，到 deployment、monitoring 和 continuous improvement。它将 data engineers、ML practitioners、software engineers 和 DevOps professionals 等多个角色结合起来，确保 machine learning systems 能在真实环境中持续交付稳定价值。

一个 production-grade machine learning system 建立在一组相互连接的 components 之上，这些 components 共同确保 reliability 和 scalability。Data pipelines 必须持续交付干净且相关的 inputs，而 feature engineering workflows 则确保 transformations 能在 training 和 serving environments 中保持 reproducible。Training processes 需要在 rapid experimentation 和 reproducibility 之间取得平衡，而 deployment mechanisms 必须通过 batch 或 real-time interfaces 安全暴露 models。Monitoring systems 在识别 data drift、performance degradation 和 anomalies 中发挥关键作用，而 MLOps practices 则通过 versioning、testing 和 continuous deployment 实现 automation。如果缺少这些元素，即使 highly accurate models 也很难在 production 中有效运行。

从实践角度看，machine learning engineering 解决的是 ML projects 中最常见的 failure points，这些问题往往不是来自糟糕的 models，而是来自薄弱的 operational foundations。它通过将 AI 无缝集成到 products 和 processes 中，使组织能够将 insights 转化为真实世界影响。对专业人员来说，它代表着从孤立实验转向构建 end-to-end systems 的转变，这些系统具备 scalability、maintainability，并且与 business objectives 对齐。

发展 machine learning engineering 专业能力，需要一种 mindset 的变化。重点不再只放在 model accuracy 上，而是转向 usability、reliability 和 long-term maintainability。这包括设计 automated data pipelines，确保 training 和 inference 之间的一致性，并采用支持 reproducibility 和 deployment 的工具。随着时间推移，实践者会开始把 machine learning 看作一个通过 feedback loops、automation 和 monitoring 持续演进的系统，而不是一次性任务。

本章将从工程视角探索 machine learning systems 的完整生命周期。我们会从 feature engineering patterns 开始，聚焦构建 reusable 和 automated transformations，使其可以在 workflows 中一致应用。随后，我们会考察 model training and experimentation，强调 structured experimentation、metadata tracking 和高效使用 compute resources 的重要性。接着，讨论会推进到 deployment strategies，分析 batch processing、API-based serving 和 real-time systems 等不同 approaches，以及 safe rollouts 的技术。然后，我们会探索 monitoring 和 drift detection，理解 systems 如何主动识别并响应 data 和 performance 的变化。最后，我们会覆盖 MLOps 和 CI/CD practices，强调 production environments 中的 automation、reliability 和 iterative improvement。

Machine learning engineering 最终弥合了 experimentation 和 real-world impact 之间的鸿沟。虽然 model accuracy 仍然重要，但真正的差异化能力在于构建 robust、scalable，并具备 continuous learning 能力的系统。通过采用 engineering-first approach，组织可以确保其 machine learning initiatives 随时间持续交付价值。

结构

本章将覆盖以下主题：

• Feature Engineering Patterns
• Model Training and Experimentation
• Model Deployment Patterns
• Monitoring and Model Drift Detection
• MLOps and CI/CD for Machine Learning

Feature Engineering Patterns

Feature engineering 是将 raw data 转换为 inputs 的过程，使 machine learning models 更有效。它是 domain knowledge 与 data science 相遇的地方，并且经常决定一个 model 是成功还是失败。一个选择得当的 feature 可以释放 model 自己永远无法学到的 insights；一个设计糟糕的 feature 则可能完全误导 model。

但在 production systems 中，feature engineering 不只是 notebook 中写几个 transformation functions。它是设计 repeatable、scalable 和 maintainable patterns，使这些 patterns 同时适用于 training 和 serving pipelines。

在 training dataset 上表现优秀的 model 并不够，如果同样的 transformations 无法在 inference 期间复现。Training 和 serving 之间 feature logic 不一致，通常称为 training-serving skew，它会在没有明显可见性的情况下导致 performance 下降。

稳健的 feature engineering patterns 会通过以下方式解决这一问题：

• 确保 environments 之间的一致性。
• 使 transformations modular、testable，并纳入 version-controlled。
• 支持跨多个 models 或 applications 复用。
• 同时支持 batch 和 real-time feature computation。
• 促进 traceability，使我们能够审计 predictions 是如何生成的。

这些能力对于构建能随时间、团队和平台可靠扩展的 ML systems 至关重要。

换句话说，feature engineering patterns 帮助我们从一次性的 hacks，走向系统化设计。

Feature Engineering Techniques

为了构建 reliable 和 performant models，必须将数据转换为最能暴露 patterns 和 relationships 的格式。下面五种技术代表了 feature engineering 中最常见、也最有影响力的 patterns。它们覆盖从处理 numeric 和 categorical variables，到处理 time-based data 和 missing values 等一系列任务。掌握这些技术，可以让实践者从 datasets 中释放更多信号，并改善 downstream learning outcomes。

Numerical Feature Transformation

Raw numerical data 通常需要 transformation，以获得更好的 performance 和 convergence。

from sklearn.preprocessing import StandardScaler, MinMaxScaler
import numpy as np
import pandas as pd

# Example Data
df = pd.DataFrame({"income": [25000, 30000, 40000, 100000, 120000]})

# Log Transform
df["log_income"] = np.log1p(df["income"])

# Min-Max Scaling
scaler = MinMaxScaler()
df["income_scaled"] = scaler.fit_transform(df[["income"]])

Categorical Encoding

许多 ML algorithms 要求 categorical variables 以 numerical 形式表示。

from sklearn.preprocessing import OneHotEncoder

# One-hot encode a column
ohe = OneHotEncoder(sparse=False)
encoded = ohe.fit_transform(df[["category"]])

ohe_df = pd.DataFrame(encoded, columns=ohe.get_feature_names_out(["category"]))
df = df.join(ohe_df)

Date and Time Feature Extraction

Timestamps 包含丰富信息，可以拆解为更有用的 components。

df["timestamp"] = pd.to_datetime(df["timestamp"])
df["day_of_week"] = df["timestamp"].dt.dayofweek
df["hour"] = df["timestamp"].dt.hour

df["hour_sin"] = np.sin(2 * np.pi * df["hour"] / 24)
df["hour_cos"] = np.cos(2 * np.pi * df["hour"] / 24)

Aggregation Features

Aggregated statistics 可以揭示 groups 或 windows 中的 patterns。

# Mean income per city
df_grouped = df.groupby("city")["income"].mean().reset_index()
df = df.merge(df_grouped, on="city", suffixes=("", "_city_mean"))

Missing Value Indicators and Imputation

Missing data 在真实世界 datasets 中很常见，必须恰当处理。

from sklearn.impute import SimpleImputer

# Add missing flag
df["age_missing"] = df["age"].isnull().astype(int)

# Median imputation
imputer = SimpleImputer(strategy="median")
df["age"] = imputer.fit_transform(df[["age"]])

这五类 patterns 构成了有效 feature engineering 的基础。它们确保 model 接收到的 inputs 经过良好缩放、具备意义，并且可解释。在后续 sections 中，我们会探索如何自动化 feature engineering、避免 data leakage，并将 feature pipelines 生产化用于真实世界 deployment。

Use Case：Predicting Customer Purchases

我们通过一个合成但现实的 use case 来理解不同类型的 feature engineering：一个 e-commerce scenario。我们处理的 customer data 包含 age、income、product interactions、region 和 purchase behavior 等 attributes。目标是预测 customer 是否会 make a purchase。

Dataset 包括：

• Customer Demographics：Age、region、income
• Behavioral Signals：products_viewed、last_purchase_days_ago
• Product Metadata：product_id
• Binary Target Variable：purchased

import pandas as pd
import numpy as np
from sklearn.preprocessing import PolynomialFeatures, KBinsDiscretizer, LabelEncoder
from sklearn.feature_selection import mutual_info_classif
from sklearn.decomposition import PCA
from sklearn.cluster import KMeans

# Create synthetic use case data
np.random.seed(42)

df = pd.DataFrame({
    'customer_id': range(1, 101),
    'age': np.random.randint(18, 60, 100),
    'income': np.random.randint(20000, 120000, 100),
    'region': np.random.choice(['North', 'South', 'East', 'West'], 100),
    'product_id': np.random.choice(['P1', 'P2', 'P3', 'P4', 'P5'], 100),
    'purchased': np.random.choice([0, 1], 100),
    'products_viewed': np.random.randint(1, 20, 100),
    'last_purchase_days_ago': np.random.randint(1, 365, 100)
})

# Target Encoding with smoothing
region_means = df.groupby('region')['purchased'].mean()
global_mean = df['purchased'].mean()
region_counts = df['region'].value_counts()
alpha = 5

df['target_encoded_region'] = df['region'].apply(
    lambda x: (region_means[x] * region_counts[x] + global_mean * alpha) / (region_counts[x] + alpha)
)

# Polynomial features
poly = PolynomialFeatures(degree=2, include_bias=False)
poly_features = poly.fit_transform(df[['age', 'income']])
poly_df = pd.DataFrame(poly_features, columns=poly.get_feature_names_out(['age', 'income']))

# Binning income
binner = KBinsDiscretizer(n_bins=4, encode='ordinal', strategy='quantile')
df['income_binned'] = binner.fit_transform(df[['income']])

# Time-based feature
df['purchase_lag'] = df['last_purchase_days_ago'].rolling(window=3, min_periods=1).mean()

# Feature interaction
df['income_per_age'] = df['income'] / (df['age'] + 1)

# Embedding with Label Encoding
le = LabelEncoder()
df['product_embedding'] = le.fit_transform(df['product_id'])

# Feature clustering
kmeans = KMeans(n_clusters=3, random_state=42)
df['cluster'] = kmeans.fit_predict(df[['age', 'income']])

# Dimensionality reduction
pca = PCA(n_components=2)
pca_components = pca.fit_transform(df[['age', 'income']])
pca_df = pd.DataFrame(pca_components, columns=['pca1', 'pca2'])

# Mutual Information scores
X = df[['age', 'income', 'income_per_age']]
y = df['purchased']
mi_scores = mutual_info_classif(X, y)
mi_df = pd.DataFrame({'feature': X.columns, 'mi_score': mi_scores})

# Synthetic feature
df['view_to_purchase_ratio'] = df['products_viewed'] / (df['purchased'] + 1)

# Combine all results
final_df = pd.concat([df.reset_index(drop=True), poly_df.reset_index(drop=True), pca_df.reset_index(drop=True)], axis=1)

现在，我们逐步讲解应用于该 dataset 的不同 feature engineering techniques，并理解其目的和实现。

Target Encoding with Smoothing

What It is：用某个 category 对应的 mean target value 替换 categorical variable，并使用 smoothing 防止 rare categories 上的 overfitting。

Use Case：我们使用 average purchase rate 对 region 进行了编码。

Feature Created：target_encoded_region

Polynomial Feature Generation

What It is：通过将现有 features 组合成 polynomial terms 来创建新 features，以捕获 non-linear relationships。

Use Case：我们生成了 age 和 income 之间的 second-degree interactions。

Features Created：age^2、income^2、age × income 等。

Binning and Discretization

What It is：将 continuous variables 转换为 discrete buckets，以降低 noise 并处理 skewed distributions。

Use Case：使用 quantile-based binning 将 income 离散化为 4 个 bins。

Feature Created：income_binned

Time-Based Feature Extraction

What It is：从 time data 中派生 features，例如 recency 或 lag，以捕获 temporal behavior。

Use Case：我们使用 last_purchase_days_ago 创建 rolling average，用来模拟 temporal lag。

Feature Created：purchase_lag

Feature Interactions

What It is：通过组合现有 features 创建新 variables，以暴露 joint effects。

Use Case：计算 income 与 age 的 ratio，用来反映某个 life stage 下的 earning power。

Feature Created：income_per_age

Embedding Representations

What It is：将 high-cardinality categorical variables 转换为 dense、numeric representations。

Use Case：使用 label encoding 对 product_id 编码，作为 embeddings 的 proxy。

Feature Created：product_embedding

Feature Clustering

What It is：应用 unsupervised clustering 对相似 entities 分组，并将 cluster ID 作为新 feature。

Use Case：基于 age 和 income 对 customers 进行 clustering。

Feature Created：cluster

Dimensionality Reduction

What It is：使用 PCA 等技术，在保留 variance 的同时减少 features 数量。

Use Case：将 age 和 income 压缩为两个 principal components。

Features Created：pca1、pca2

Mutual Information for Feature Selection

What It is：根据 features 能减少多少 target uncertainty 来打分，可以捕获 non-linear dependencies。

Use Case：识别 age、income 和 income_per_age 中，哪些对 purchased 最有信息量。

Output：Mutual information scores

Synthetic Feature Generation

What It is：基于 domain logic 和 variable combinations 手工构造新 features。

Use Case：创建 view_to_purchase_ratio，用于量化 user engagement quality。

Feature Created：view_to_purchase_ratio

这些技术中的每一种都会给数据增加一个新的观察视角，突出 raw variables 自身无法表达的 patterns。下一节中，我们将探索如何评估这些 features，并将它们纳入稳健的 model training workflows。

Model Training and Experimentation

当数据已经完成清洗、特征工程和整理后，machine learning lifecycle 的下一阶段就是 model training，也就是学习将 inputs 映射到 outcomes 的数学模式。然而，实践中，training 很少是一次性活动。它是一种迭代的、实验性的 workflow，涉及 algorithm selection、hyperparameter tuning、evaluation，以及多个 model variants 的 comparison。

从核心上看，experimentation 是一个受控的科学过程。多个 models 会在不同 configurations 下训练，它们的 performance 会被度量，然后基于信息充分的判断决定哪个 version 应该被提升到 production。但如果 experimentation 缺乏 reproducibility，就会很有风险。如果结果无法 recreate、trust 或 audit，系统很快会失去可靠性。

因此，现代 model training 必须被视为一个 systematic、repeatable 和 traceable 的过程，其中包括：

• 基于 problem type 选择 algorithms，例如 classification、regression 等。
• 使用一致策略将 data 拆分为 training、validation 和 test sets。
• 跟踪 datasets 和 feature versions，以确保 artifact lineage。
• 捕获 hyperparameters、code versions 和 random seeds，以支持 reproducibility。
• 记录 evaluation metrics 和 comparison results。
• 记录 model artifacts，以及其 training environment，例如 library versions、dependencies 和 hardware configuration。

Reproducibility 保证同样的数据和 configuration 会产生同样的 model。Artifact lineage 确保我们知道某个 model 是由哪个 dataset、feature transformations 和 code version 生成的。Environment capture 防止因 library 或 dependency changes 造成的微妙 failure。

在 production-grade systems 中，training 不只是优化 accuracy；它是构建透明、可审计的 pipeline，在这个 pipeline 中，每个 model 都可以被 trace、replicate 和 govern。

随着 experimentation 复杂度提升，使用 notebooks 和 spreadsheets 管理它会变得不可持续。以下工具可以帮助自动化并组织这一过程：

Tool	Purpose
MLflow	记录 parameters、metrics、models 和 artifacts
Weights and Biases（W&B）	带丰富 visualizations 的 real-time experiment tracking
Data Version Control（DVC）	跟踪 data 和 model versions
Optuna / Hyperopt	自动化 hyperparameter tuning
scikit-learn Pipelines	将 preprocessing 和 modeling 组织为 reproducible components

表 9.1：Model Experimentation 工具

这些工具帮助 teams 标准化 experimentation，并确保 results 的存储、比较和检索方式保持一致。

Use Case：Predicting Customer Churn

在 subscription-driven business 中，customer retention 与 customer acquisition 同样关键。Churn prediction models 可以帮助识别可能 cancel subscriptions 的 customers，使业务能够主动介入。

在这个 use case 中，我们使用一个包含以下内容的 dataset：

• Demographics：Age、gender、region
• Usage Behavior：avg_monthly_usage、last_login_days_ago、num_support_tickets
• Engagement：subscription_tier、has_discount、feedback_score
• Target：churned，二分类变量，1 = churned，0 = retained

目标是训练 models，准确预测 churn，并尝试多种 algorithms，以在保持 precision 的同时最大化 recall。

Preparing the Dataset

import pandas as pd
from sklearn.model_selection import train_test_split

# Synthetic dataset creation
df = pd.DataFrame({
    'age': np.random.randint(18, 60, 100),
    'avg_monthly_usage': np.random.uniform(2, 50, 100),
    'last_login_days_ago': np.random.randint(1, 60, 100),
    'num_support_tickets': np.random.randint(0, 5, 100),
    'subscription_tier': np.random.choice(['Basic', 'Standard', 'Premium'], 100),
    'has_discount': np.random.choice([0, 1], 100),
    'feedback_score': np.random.uniform(1, 5, 100),
    'churned': np.random.choice([0, 1], 100)
})

Feature Engineering

我们对 categorical variables 进行 encoding，并派生 interaction terms。

from sklearn.preprocessing import OneHotEncoder

# One-hot encode subscription tier
df = pd.get_dummies(df, columns=['subscription_tier'], drop_first=True)

# Feature interaction
df['usage_per_ticket'] = df['avg_monthly_usage'] / (df['num_support_tickets'] + 1)

Train-Test Split

features = [col for col in df.columns if col != 'churned']
X = df[features]
y = df['churned']

X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, random_state=42)

Training a Gradient Boosting Model

Gradient boosting models，例如 XGBoost 或 LightGBM，非常适合 churn problems，因为它们可以处理 class imbalance，并捕获 non-linear patterns。

from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import classification_report, roc_auc_score

gbm = GradientBoostingClassifier(n_estimators=100, learning_rate=0.1, max_depth=4)
gbm.fit(X_train, y_train)

y_pred = gbm.predict(X_test)
y_proba = gbm.predict_proba(X_test)[:, 1]

print("AUC Score:", roc_auc_score(y_test, y_proba))
print(classification_report(y_test, y_pred))

Experiment Tracking with Weights and Biases（W&B）

import wandb

wandb.init(project="churn-prediction", name="GBM-Run-1")

wandb.config.update({
    "model": "GradientBoosting",
    "n_estimators": 100,
    "learning_rate": 0.1,
    "max_depth": 4
})

wandb.log({
    "roc_auc": roc_auc_score(y_test, y_proba)
})

wandb.finish()

这可以实现 experiments 的 real-time logging 和 visualization、runs 之间的比较，以及随时间对 performance 进行详细分析。

这个 use case 展示了 model experimentation 不只是 model tuning，而是一个系统化创建、比较和学习的科学过程。在 operational settings 中，这类 workflows 可以帮助 businesses 做出 data-driven decisions，并大规模交付 personalized customer experiences。

Model Deployment Patterns

训练 machine learning model 只完成了一半工作。真正的价值，是当 models 的 predictions 被 customers、business systems 或 internal users 用于做决策时才实现的。这一步被称为 deployment，它是 notebook 中表现良好的 model 与真实世界中创造影响的 system 之间的桥梁。

没有 deployment：

• Predictions 无法服务 applications 或 users。
• Models 无法被 data science team 以外访问。
• 这项努力无法产生可衡量的 business value。

Model deployment 解决的是 machine learning 运营化的问题——将 experimentation 转化为 real-time、on-demand intelligence，并无缝集成到 existing systems 中。

Types of Model Deployment Patterns

根据 use case、latency requirements 和 infrastructure，models 可以用不同方式部署。每种 pattern 适合特定类型的 application。以下是最常见的 model deployment strategies。

Batch Inference

What It is：按 scheduled intervals，为一组 data points 生成 predictions，尤其是 daily 或 hourly。

Where It is Used：

• Monthly churn risk scoring
• 对所有 customers 做 creditworthiness assessment
• Weekly product demand forecasting

How It Works：

• Model 在一个 data batch 上运行，数据来自 warehouse 或 file system。
• Predictions 被写回 database 或 storage。
• Downstream systems 消费结果。

Advantages：

• 易于实现。
• 适合 non-real-time use cases。

Limitations：不适合 low-latency 或 user-triggered predictions。

Online（Real-Time）Inference

What It is：收到 input data 后立即生成 predictions，通常通过 API endpoint。

Where It is Used：

• Payment 期间的 fraud detection。
• Checkout 期间的 product recommendation。
• Personalized news / article feeds。

How It Works：

• Model 托管在 REST / gRPC API 后面。
• Applications 向 endpoint 发送 input 并接收 predictions。

Advantages：

• Immediate response。
• 与 front-end 和 real-time systems 无缝集成。

Limitations：

• 需要 scalable、low-latency infrastructure。
• 需要 monitoring 和 fault tolerance。

On-Device Inference

What It is：Models 被部署在 mobile phones、IoT devices 或 edge servers 本地。

Where It is Used：

• Voice assistants，包括 Google Assistant 和 Siri。
• Camera-based object detection，类似 self-driving cars。
• Rural areas 中的 offline health diagnostics。

How It Works：

• 导出 lightweight versions 的 models，例如 TensorFlow Lite 和 CoreML。
• 直接在 device 上运行，不需要 server。

Advantages：

• 无需 internet 也可以工作。
• 因本地处理而更快。

Limitations：

• 受 device hardware 限制。
• 难以频繁更新。

Embedded Deployment

What It Is：Model predictions 直接集成进现有 application，例如 Excel、SQL query 或 BI dashboard。

Where It is Used：

• Loan approval tools。
• Internal CRM scoring widgets。
• Rule-based recommendation overlays。

How It Works：

• Model outputs 被嵌入 business logic。
• 可以通过 APIs、Excel formulas 或 stored procedures 执行。

Advantages：

• Business users 使用起来快速且低摩擦。
• 不需要复杂 infra。

Limitations：

• 可能不太容易扩展。
• 通常与 business tools 紧耦合。

Use Case：Real-Time Fraud Detection

考虑一个面向 online payment platform 的 real-time fraud detection model。系统需要在 transaction 发起后的毫秒内判断其是否可疑，并决定是否阻止。

Problem：Fraudulent transactions 会造成数百万损失，并且必须在发生时被检测出来，而不是事后检测。

Solution：使用 online inference 部署 fraud detection model。

How It Works：

• 一个 trained model，例如 XGBoost 或 neural network，被 serialized，例如使用 joblib 或 pickle。
• 它通过 Flask / FastAPI / TensorFlow Serving / TorchServe web service 提供服务。
• 当 user 发起 payment 时，transaction metadata，例如 amount、location、device、time 等，会被发送到 model API。
• Model 返回 fraud risk score，例如 0.91，application 根据该 score approve 或 block transaction。

# Example using FastAPI
from fastapi import FastAPI
import joblib
import pandas as pd

model = joblib.load("fraud_model.pkl")
app = FastAPI()

@app.post("/predict")
def predict(transaction: dict):
    data = pd.DataFrame([transaction])
    prediction = model.predict_proba(data)[0, 1]
    return {"fraud_score": prediction}

这个 setup 支持 scalable、real-time predictions，并与核心 transaction system 集成。可以进一步添加 load balancing、health checks 和 caching，以提升 robustness。

Model deployment 是 machine learning 变得有用的地方。无论 use case 需要 real-time inference、periodic batch updates，还是 lightweight mobile execution，选择正确的 deployment pattern 对确保 reliability、performance 和 business alignment 都至关重要。

Monitoring and Model Drift Detection

Model 一旦部署，很容易让人觉得工作已经完成。但这正是新责任开始的地方：持续监控 model 随时间变化的行为，确保它依然 reliable、accurate 和 trustworthy。

在动态环境中，data 会演进。Customer behavior 也会变化。Market conditions 会转变。Infrastructure 会更新。一个在开发期间表现良好的 model，可能会随着时间推移开始做出糟糕 predictions。这种现象被称为 model drift，如果不加检查，它可能导致糟糕 business decisions，并损害人们对 AI systems 的信任。

Monitoring 是持续检查已部署 model 的 health、inputs 和 outputs 的过程。它帮助检测是否出现问题——无论是 data pipeline 问题、data distribution 变化，还是 performance degradation。

Types of Drift

理解 drift，是设计有效 monitoring system 的关键。主要有三类：

Data Drift（Covariate Drift） ：当 input features 的 distribution 随时间变化时发生。

示例：Customers 的 age distribution 从主要 30–40 岁转向 50+ 岁。

Concept Drift：当 inputs 与 outputs 之间的 relationship 发生变化时出现。

示例：过去不被视为 fraudulent 的 transactions，由于 fraud tactics 变化，现在开始表现为 fraudulent。

Target Drift：当 target variable 的 distribution 发生变化时出现。

示例：由于新的 retention campaign，churn rate 突然下降。

一个有效的 monitoring system 会观察多个维度：

Monitoring Aspect	Description
Data Quality	Missing values、invalid types、unexpected formats
Feature Distributions	Histogram changes、outliers、spikes
Prediction Distributions	Confidence scores、class probability shifts
Model Performance	Accuracy、precision、recall，如果 ground truth 可用
Latency and Throughput	Predictions 耗时、requests 数量
Service Health	API uptime、error rates

表 9.2：Production 中的 Monitoring Aspects

Use Case：Credit Risk Model Drift Monitoring

考虑一个用于评估 loan default likelihood 的 credit risk model。该 model 作为 API 部署，会实时为每个 applicant 打分。

Initial Setup：

• Model 使用 2024 年 1 月到 3 月的 customer data 训练。
• Features 包括 age、income、loan_amount、credit_history。
• Target variable：defaulted，0 或 1。

Monitoring Goals：

• 检测 applicant profiles 是否发生显著变化，包括 post-policy changes。
• 观察 model confidence 是否上升，但 actual accuracy 并没有上升。
• 如果 default prediction distribution 变化过大，则触发 alerts。

Implementation Strategy

下面分步骤来看 implementation strategy。

1. Logging Inputs and Outputs

设置 pipeline，记录每次 API request 和 prediction：

# Pseudocode
log_entry = {
    'timestamp': datetime.now(),
    'features': input_data,
    'prediction': model.predict(input_data),
    'confidence': model.predict_proba(input_data)[0, 1]
}

write_to_storage(log_entry)

2. Monitoring Feature Drift（Evidently Example）

from evidently.report import Report
from evidently.metric_preset import DataDriftPreset

reference_data = df_jan2024
current_data = df_may2024

report = Report(metrics=[DataDriftPreset()])
report.run(reference_data=reference_data, current_data=current_data)
report.save_html("drift_report.html")

这个 report 会突出显示哪些 features 正在 drift、漂移程度如何，以及这些变化是否具有统计意义。

3. Monitoring Prediction Distributions

使用 daily 或 weekly aggregation 来跟踪：

• Mean predicted risk score
• Standard deviation
• 被预测为 high-risk 的 applicants 数量

如果任一 metric 超过定义好的 threshold，就触发 alerts。

4. Ground Truth Feedback Loop

如果 true outcomes，例如 defaulted loans，会在延迟后可用，就可以设置 rolling evaluation：

from sklearn.metrics import roc_auc_score

actuals = get_actuals_last_month()
predictions = get_predictions_last_month()

auc = roc_auc_score(actuals, predictions)

if auc < 0.65:
    send_alert("Model AUC dropped below threshold")

这可以确保 model 保持 calibrated 和 accurate。

Monitoring 不只是观察，而是为了采取行动。如果检测到 drift，并确认其影响 performance，就必须重新训练 model。

一个好实践是按 schedule 自动 retraining，例如每月一次，或者基于 trigger，例如 AUC 低于 threshold，或超过 3 个 features 发生 drift。使用 Kubeflow、Airflow 或 Vertex AI Pipelines 等工具，将 retraining 集成到 MLOps pipeline 中，可以确保 continuous learning。

Monitoring 和 drift detection 可以确保 machine learning systems 在部署很久之后，仍然保持 trustworthy、transparent 和 effective。通过持续关注 data、predictions 和 model health，我们可以确保 systems 与真实世界保持一致，即使世界本身在不断变化。

MLOps and CI/CD for Machine Learning

随着 machine learning systems 成熟，部署 model 不再是 workflow 的终点，而是 continuous lifecycle 的起点。在真实世界中，data 会变化，business goals 会演进，model performance 会随时间退化。为了管理这种复杂性，组织需要的不只是优秀 models，还需要稳健 pipelines，能够持续且可靠地 retrain、test、monitor 和 deploy models。

这正是 Machine Learning Operations（MLOps）和 Continuous Integration and Continuous Deployment（CI/CD）发挥作用的地方。它们共同提供将 machine learning models 推向 production，并让它们安全、有效地持续运行所需的 practices 和 automation。

MLOps：Machine Learning Operations

MLOps 是一组结合 Machine Learning、DevOps 和 Data Engineering 的 practices，用于简化 ML systems 的 end-to-end lifecycle。它使 teams 能够在规模化条件下围绕 model lifecycle 进行 collaboration、automation 和 governance，从 data preparation 到 model monitoring。

不同于传统软件，machine learning systems 会受到以下因素影响：

• Changing data distributions
• Model degradation over time，也就是 drift
• Non-deterministic outputs
• 多个 components，例如 data pipelines、models、evaluation

如果没有 MLOps：

• Retraining 是手工且不一致的。
• Experiments 难以复现。
• Model versions 不被跟踪。
• Deployment 和 rollback processes 容易出错。

MLOps 提供了将 experiments 转化为 reliable、maintainable systems 所需的结构和自动化。

MLOps 包括：

• Code、data 和 models 的 versioning。
• Experiment tracking 和 comparison。
• Model packaging 和 registration。
• 面向 training 和 retraining 的 automated workflows。
• Performance monitoring 和 alerting。

这些 components 通常通过 pipelines 编排，覆盖从 raw data 到 production deployment 的每一个步骤。

Function	Tools
Experiment Tracking	MLflow、Weights and Biases、Neptune
Data and Model Versioning	DVC、Pachyderm
Workflow Orchestration	Kubeflow Pipelines、Airflow、Prefect
Model Registry	MLflow Registry、SageMaker Registry
Monitoring	Evidently、Arize、Fiddler、Prometheus

表 9.3：MLOps 工具

CI/CD for Machine Learning

CI/CD 代表 Continuous Integration 和 Continuous Deployment，是 DevOps 的两个关键原则。在软件领域，CI/CD pipelines 允许 developers 集成 code changes、运行 automated tests，并快速可靠地 deploy applications。

应用到 ML 时，CI/CD 会自动化：

• 当 data 或 code changes 时，进行 model training 和 validation，也就是 CI。
• 将 validated models 部署到 production environments，也就是 CD。

Machine learning projects 经常遭遇以下问题：

• Teams 之间 manual handoffs。
• Deployment processes 不一致。
• 难以基于 new data retrain models。

CI/CD 通过以下方式解决这些问题：

• 缩短 model development 和 deployment 之间的时间。
• 确保每个 step 都 reproducible 和 testable。
• 支持 safe rollback，以及在 staging environments 中 testing。

CI/CD 的工作方式如下：

1. Trigger：code 或 data change 启动 pipeline。
2. Preprocessing and Feature Engineering：自动化并纳入 version-controlled。
3. Training and Validation：记录 metrics，并执行 thresholds。
4. Model Registration：只有 successful models 被存储到 registry。
5. Deployment：model 被部署到 staging / production。
6. Monitoring：Post-deployment checks 确保 performance consistency。

CI/CD Component	Tools
CI Pipelines	GitHub Actions、GitLab CI、Jenkins
Model Deployment	FastAPI、Docker、KServe、SageMaker
Workflow Integration	MLflow、Airflow、Argo Workflows
Alerts / Notifications	Slack Bots、Email Hooks、Prometheus Alerts

表 9.4：CI/CD 工具

Use Case：为 Churn Prediction Model 自动化 Retraining 和 Deployment

一家 telecom company 使用 machine learning model 来预测哪些 customers 可能在未来 30 天 churn。Model 每月使用更新后的 customer activity data 训练一次，并以 real-time 方式向 customer retention team 提供 predictions。

Problem：

如果没有 MLOps 和 CI/CD：

• Retraining 由 data scientists 手工完成。
• 没有系统跟踪 model performance drift。
• 每次 deployment 都需要 engineering support。

Solution：

使用 MLOps 和 CI/CD 实现 automated pipeline：

Data Trigger：当新的 monthly data 落入 data warehouse 时，pipeline 被触发。

Data Validation：检查 schema changes 和 missing values。

Model Training：使用 XGBoost，并进行 parameter tuning 和 logging。

Evaluation：将 AUC、precision 和 recall 等 metrics 与 previous runs 对比。

Registry and Deployment：如果 model 通过 thresholds，就注册该 model，并通过 Dockerized API 推送到 production。

Monitoring：Daily drift detection reports 发送到 Slack；如果 drift 超过限制，则触发 retraining。

Technologies Used：

• MLflow 用于 experiment tracking 和 model registry。
• GitHub Actions 用于触发 training pipelines。
• Docker + FastAPI 用于 deployment。
• Evidently AI 用于 drift monitoring。
• Slack Bot 用于 alerting。

MLOps 和 CI/CD 对交付 machine learning systems 至关重要，这些系统不仅要 accurate，还要 reliable、scalable 和 production-ready。它们将 data science 从一次性项目转变为一个 continuous、iterative 的 learning 和 improvement cycle。

借助合适工具和 workflows，组织可以降低 manual overhead、提升 reproducibility、尽早检测 model decay，并自动交付能够适应真实世界的 insights。

结论

本章探索了将 machine learning 从 experimentation 推向 real-world application 所需的内容。我们首先理解了 model training 和 experimentation 不只是构建最 accurate 的 model，而是运行 structured、repeatable processes，以支持 comparison、tracking 和 continuous improvement。

随后，我们考察了 deployment patterns，学习 models 如何根据 application needs，以 batch、real-time、on-device 或 embedded formats 提供服务。这自然引出了 monitoring 的重要性——它不仅用于 system health，也用于 detecting data drift，并确保系统在动态环境中持续保持 performance。

最后，我们介绍了 MLOps 和 CI/CD，它们帮助标准化和自动化 machine learning lifecycle，从 data ingestion 到 model deployment 和 monitoring。MLOps frameworks 为跨组织构建 scalable、reproducible 和 reliable ML systems 提供基础。

这些实践共同弥合 model development 和 business value 之间的鸿沟，确保 machine learning systems 在 initial deployment 之后仍然可以 adapt、scale，并持续运行。

正如我们已经看到的，operationalizing machine learning 需要的不只是 models，它还高度依赖支撑这些 models 的 data quality。下一章中，我们将把重点转向 data quality patterns，探索如何在 pipelines 中 validate、monitor 和 enforce data integrity，以确保 downstream applications，包括 ML models，始终 trustworthy 和 effective。