图像预处理加速：归一化与减均值的SIMD优化、颜色空间转换的加速技巧、使用GPU进行批量预处理

图像预处理，说白了就是模型推理前的「洗菜切菜」环节。很多同学觉得这步没啥技术含量，随便写个循环就完事了。但我在实际项目中吃过亏——有一次线上服务，预处理占了整个推理pipeline的40%时间，你说气不气人？

今天我们就来聊聊，怎么把这「洗菜切菜」的功夫练到极致。

归一化与减均值的SIMD优化

先说说归一化。常见的操作是：(pixel - mean) / std。很多框架的官方demo里，直接拿numpy或者Python列表推导式就搞定了。但你要是真这么干，推理速度直接打五折。

我个人习惯用SIMD指令集来做。为什么？因为归一化本质上就是一组「加载-运算-存储」的流水线操作，SIMD一次能处理4个float或者8个int，效率翻倍。

来看一个实际例子。假设输入是RGB三通道的uint8图像，我们要做减均值再除以标准差：

// 使用SSE指令集做归一化
void normalize_sse(const uint8_t* src, float* dst, 
                   float mean_r, float mean_g, float mean_b,
                   float std_r, float std_g, float std_b, int size) {
    // 加载均值向量
    __m128 mean = _mm_set_ps(mean_b, mean_g, mean_r, 0.0f);
    __m128 std  = _mm_set_ps(std_b, std_g, std_r, 1.0f);
    
    for (int i = 0; i < size; i += 4) {
        // 加载4个像素（12个通道值）
        // 这里用_mm_loadu_si128加载16字节
        __m128i src_vec = _mm_loadu_si128((__m128i*)(src + i * 3));
        
        // 拆分成RGB分量
        // ... 具体拆包逻辑略复杂，这里展示核心思路
        
        // 转float并做归一化
        __m128 r_float = _mm_cvtepi32_ps(_mm_unpacklo_epi16(...));
        r_float = _mm_sub_ps(r_float, mean);
        r_float = _mm_div_ps(r_float, std);
        
        // 存回内存
        _mm_storeu_ps(dst + i, r_float);
    }
}

你可能会问：那ARM平台怎么办？嗯，NEON指令集思路完全一样，只是指令名字换了一套。比如vld1q_u8对应加载，vsubq_f32对应减法。

颜色空间转换的加速技巧

颜色空间转换，最常见的就是RGB转BGR、RGB转灰度、RGB转YUV。这些操作看起来简单，但架不住数据量大啊。一张4K图片，几百万个像素点，每个点都要做矩阵乘法，CPU扛不住的。

我在项目中遇到过一个问题：模型要求输入是BGR格式，但摄像头采集的是RGB。一开始我直接用cv::cvtColor，后来发现这个函数在批量处理时成了瓶颈。

怎么加速？三个思路：

1. 查表法：对于RGB转灰度这种线性变换，提前算好所有可能的映射值。因为RGB每个通道只有256种取值，查表比实时计算快得多。
2. 整数运算代替浮点：比如RGB转YUV的公式里有0.299、0.587这些系数。你可以把它们放大成整数（比如乘以1024），最后再右移。这样避免了浮点运算。
3. SIMD并行：和归一化一样，颜色转换也是逐像素操作，天然适合SIMD。

来看一个查表法的例子：

// RGB转灰度 - 查表法
void rgb2gray_lut(const uint8_t* rgb, uint8_t* gray, int width, int height) {
    // 预计算查表
    static uint8_t lut[256][256][256]; // 这太大了，实际用3个一维表
    static bool initialized = false;
    if (!initialized) {
        for (int r = 0; r < 256; r++)
            for (int g = 0; g < 256; g++)
                for (int b = 0; b < 256; b++)
                    lut[r][g][b] = (uint8_t)(0.299f * r + 0.587f * g + 0.114f * b);
        initialized = true;
    }
    
    // 查表转换
    for (int i = 0; i < width * height; i++) {
        gray[i] = lut[rgb[i*3]][rgb[i*3+1]][rgb[i*3+2]];
    }
}

使用GPU进行批量预处理

好了，前面说的都是CPU上的优化。但如果你有GPU，干嘛不用呢？GPU做图像预处理简直是降维打击。

我记得有一次，客户要求同时处理32路视频流，每路1080p。CPU上做归一化+颜色转换，CPU直接飙到90%。后来我把预处理搬到GPU上，CPU占用降到10%，GPU利用率才30%。

GPU批量预处理的典型流程：

1. 批量传输：把多张图片拼成一个batch，一次性传到GPU显存。不要一张一张传，PCIe带宽很贵的。
2. CUDA kernel：写一个kernel，每个线程处理一个像素。归一化、颜色转换、resize全在一个kernel里搞定。
3. 异步流水线：用CUDA Stream实现「传输-计算-传输」的流水线，隐藏传输延迟。

来看一个CUDA kernel的简化版：

// CUDA kernel：批量归一化+RGB转BGR
__global__ void preprocess_kernel(const uint8_t* src, float* dst,
                                  int batch_size, int height, int width,
                                  float mean_r, float mean_g, float mean_b,
                                  float std_r, float std_g, float std_b) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    int total_pixels = batch_size * height * width;
    
    if (idx < total_pixels) {
        int batch_idx = idx / (height * width);
        int pixel_idx = idx % (height * width);
        
        // 读取RGB（假设输入是RGB格式）
        uint8_t r = src[idx * 3 + 0];
        uint8_t g = src[idx * 3 + 1];
        uint8_t b = src[idx * 3 + 2];
        
        // 归一化并转成BGR（模型要求）
        dst[idx * 3 + 0] = (b / 255.0f - mean_b) / std_b;
        dst[idx * 3 + 1] = (g / 255.0f - mean_g) / std_g;
        dst[idx * 3 + 2] = (r / 255.0f - mean_r) / std_r;
    }
}

看到没？GPU批量处理时，32张图片只比单张多了3.2ms。这就是批量的威力。

最后说一句，预处理加速不是一锤子买卖。我建议你先把pipeline搭起来，然后用profiler跑一遍，看看瓶颈在哪。很多时候，一个简单的内存对齐优化，效果比换算法还明显。

嗯，今天就聊到这儿。下一章我们讲讲模型推理时的内存管理，那个坑更多。