3. 特征预处理加速：特征工程中的瓶颈分析

在XGBoost评分服务中，特征预处理往往占据端到端延迟的40%–60%。原始数据必须经过缺失值填充、类别编码、数值缩放、交叉特征构造等步骤，才能送入模型。如果这些步骤采用逐行Python循环实现，单次预测延迟可能从微秒级膨胀到毫秒级，成为系统瓶颈。

3.1 瓶颈定位：逐行处理的代价

以下代码展示了一个典型的逐行特征变换模式：

def transform_row(row):
    # 逐行处理：缺失值填充 + 对数变换 + 分箱
    if row['age'] is None:
        row['age'] = 30.0
    row['log_income'] = math.log(row['income'] + 1e-6)
    if row['score'] < 60:
        row['score_bin'] = 0
    elif row['score'] < 80:
        row['score_bin'] = 1
    else:
        row['score_bin'] = 2
    return row

# 逐行循环
for i in range(len(df)):
    df.iloc[i] = transform_row(df.iloc[i])

这种模式的性能瓶颈来自三个方面：

3.2 向量化操作：用NumPy/Pandas替代逐行循环

向量化的核心思想是将循环下推到C语言层面执行。Pandas和NumPy的底层实现使用C/Cython，对连续内存块进行批量操作，避免了Python解释器的逐行开销。

将上述逐行代码改写为向量化版本：

import numpy as np
import pandas as pd

def transform_vectorized(df):
    # 缺失值填充：整列操作
    df['age'] = df['age'].fillna(30.0)
    
    # 对数变换：向量化数学运算
    df['log_income'] = np.log(df['income'] + 1e-6)
    
    # 分箱：使用np.select替代if-else
    conditions = [
        df['score'] < 60,
        df['score'] < 80,
        df['score'] >= 80
    ]
    choices = [0, 1, 2]
    df['score_bin'] = np.select(conditions, choices, default=2)
    
    return df

向量化与逐行处理的性能对比：

3.3 利用Numba加速复杂特征变换

当特征变换逻辑包含复杂的数学公式、条件分支或循环依赖时，纯向量化可能难以表达。此时可以使用Numba——一个JIT编译器，将Python函数编译为机器码。

Numba的核心用法：

import numba
import numpy as np

@numba.jit(nopython=True, parallel=True)
def complex_feature_transform(data):
    """
    复杂特征变换：包含条件逻辑和数学运算
    data: (n_samples, n_features) numpy数组
    """
    n = data.shape[0]
    result = np.empty((n, 3))
    
    for i in numba.prange(n):  # 并行循环
        x = data[i, 0]
        y = data[i, 1]
        z = data[i, 2]
        
        # 复杂条件逻辑
        if x > 0.5 and y < 0.3:
            result[i, 0] = np.exp(x * y) + np.log(z + 1e-8)
        elif x <= 0.5 and z > 0.7:
            result[i, 0] = np.sin(x * 3.14) * np.cos(y * 2.71)
        else:
            result[i, 0] = np.sqrt(np.abs(x - y) + z)
        
        # 分箱逻辑
        if result[i, 0] < 0.2:
            result[i, 1] = 0
        elif result[i, 0] < 0.6:
            result[i, 1] = 1
        else:
            result[i, 1] = 2
        
        # 交叉特征
        result[i, 2] = (x + y + z) / (1 + np.abs(x - y))
    
    return result

Numba加速效果对比：

3.4 使用Cython编译关键路径

对于需要与现有C/C++库交互或对内存布局有精细控制的场景，Cython是更合适的选择。Cython允许在Python代码中嵌入C类型声明，然后编译为C扩展模块。

Cython加速示例（保存为 feature_transform.pyx）：

# feature_transform.pyx
import numpy as np
cimport numpy as np
from libc.math cimport exp, log, sin, cos, sqrt, fabs

def transform_cython(np.ndarray[np.float64_t, ndim=2] data):
    cdef int n = data.shape[0]
    cdef int i
    cdef np.ndarray[np.float64_t, ndim=2] result = np.empty((n, 3))
    cdef double x, y, z
    
    for i in range(n):
        x = data[i, 0]
        y = data[i, 1]
        z = data[i, 2]
        
        if x > 0.5 and y < 0.3:
            result[i, 0] = exp(x * y) + log(z + 1e-8)
        elif x <= 0.5 and z > 0.7:
            result[i, 0] = sin(x * 3.14) * cos(y * 2.71)
        else:
            result[i, 0] = sqrt(fabs(x - y) + z)
        
        if result[i, 0] < 0.2:
            result[i, 1] = 0.0
        elif result[i, 0] < 0.6:
            result[i, 1] = 1.0
        else:
            result[i, 1] = 2.0
        
        result[i, 2] = (x + y + z) / (1.0 + fabs(x - y))
    
    return result

编译与调用：

# setup.py
from setuptools import setup
from Cython.Build import cythonize

setup(
    ext_modules = cythonize("feature_transform.pyx")
)

# 编译命令
# python setup.py build_ext --inplace

# 调用
from feature_transform import transform_cython
result = transform_cython(data_np)

3.5 三种加速方案选型指南

3.6 实战建议：构建加速特征流水线

1. 先分析，后优化： 使用Python的cProfile或line_profiler定位特征预处理中的热点函数。通常20%的代码占据80%的延迟。
2. 分层加速策略：
   • 第一层：将能向量化的操作全部改写为NumPy/Pandas列操作。
   • 第二层：对剩余复杂逻辑使用Numba的@jit(nopython=True)装饰。
   • 第三层：对极致性能要求且稳定的模块，用Cython编译为扩展。
3. 缓存不变特征： 如果某些特征变换在多次预测间保持不变（如分箱边界、缩放参数），提前计算并缓存，避免重复执行。
4. 批量预测接口： 将单条预测接口设计为支持批量输入（batch_size ≥ 64），让向量化和Numba的并行能力充分发挥。