如何将指定范围的数值量化为任意数量分箱？优先Python+Numpy实现

嘿，这个需求我之前做数值量化处理的时候刚好碰到过，用Numpy就能高效解决，分两种情况给你详细说：

Numpy自带的矢量化工具完全能搞定这个需求，比纯Python循环效率高几个数量级，尤其适合大规模数组。核心思路是先生成等宽分箱的边界，再通过digitize快速定位每个值的分箱位置，最后映射到对应的分箱代表值。

import numpy as np

def quantize_to_bins(arr, num_bins):
    # 获取数组的极值
    Y = arr.min()
    X = arr.max()
    
    # 边界情况：分箱数为1时，所有值量化为同一个值（这里选最小值，可按需调整为最大值/中间值）
    if num_bins == 1:
        return np.full_like(arr, Y)
    
    # 生成等宽分箱的边界（左闭右开区间）
    bins = np.linspace(Y, X, num_bins + 1)
    # 定位每个元素所在的分箱索引（digitize返回1-based索引，转成0-based更方便）
    bin_indices = np.digitize(arr, bins, right=False) - 1
    
    # 按你的示例逻辑：每个分箱映射到该分箱的上限（比如2分箱时，第一箱→Y，最后一箱→X）
    # 如果需要其他映射规则（比如分箱中间值），直接修改bin_values即可
    bin_values = bins[1:]
    
    # 完成量化映射
    quantized_arr = bin_values[bin_indices]
    
    # 如果你需要整数结果（比如示例中的floor操作），可以加上这行
    # quantized_arr = np.floor(quantized_arr).astype(np.int64)
    
    return quantized_arr

举个和你示例匹配的测试：

# 测试数组：0到65535的随机整数
test_arr = np.random.randint(0, 65536, size=1000)
# 量化为2分箱
quantized = quantize_to_bins(test_arr, 2)
# 验证：<=32767的变成32767.5？不对，你的示例是要变成0和65535，那修改bin_values即可：
bin_values = np.array([Y, X])  # Y=0, X=65535
quantized_custom = bin_values[bin_indices]

当分箱数是2的幂次（比如2、4、8...）时，我们可以利用数学特性进一步优化，尤其是处理整数数组时，位运算能带来极致的速度提升。

整数数组的位运算优化 #

如果你的数组是整数，且极值范围X-Y+1是2的幂次（比如65535-0+1=65536=2^16），可以直接用位运算代替除法/乘法，速度快很多：

def quantize_power_of_two_int(arr, k):
    # k是幂次，分箱数为2^k
    num_bins = 2 ** k
    Y = arr.min()
    X = arr.max()
    range_val = X - Y
    
    if num_bins == 1:
        return np.full_like(arr, Y)
    
    # 计算移位位数：把数值压缩到0~num_bins-1的范围
    shift_bits = (range_val + 1).bit_length() - 1 - k
    # 位运算快速获取分箱索引
    indices = (arr - Y) >> shift_bits
    # 映射到分箱上限（完全匹配你2分箱的示例逻辑：0→0，1→65535）
    quantized = Y + ((indices + 1) << shift_bits) - 1
    
    return quantized

测试你的示例场景：

test_arr = np.random.randint(0, 65536, size=1000)
# 2分箱（k=1）
quantized = quantize_power_of_two_int(test_arr, 1)
# 结果：<=32767的变成32767？不对，要变成0的话，直接修改映射逻辑：
quantized_custom = np.where(indices == 0, Y, X)

浮点数数组的优化 #

对于浮点数数组，我们可以利用2的幂次的倒数运算更快的特性（浮点数乘法比除法高效）：

def quantize_power_of_two_float(arr, k):
    num_bins = 2 ** k
    Y = arr.min()
    X = arr.max()
    range_val = X - Y
    
    if num_bins == 1:
        return np.full_like(arr, Y)
    
    # 用乘法代替除法，提升效率
    norm_factor = num_bins / range_val
    # 归一化后取整得到分箱索引
    indices = np.floor((arr - Y) * norm_factor).astype(np.int64)
    # 防止极值超出索引范围
    indices = np.clip(indices, 0, num_bins - 1)
    
    # 映射到分箱上限
    quantized = Y + (indices + 1) * (range_val / num_bins)
    
    return quantized

通用分箱伪代码 #

function quantize_to_bins(arr, num_bins):
    Y = minimum value of arr
    X = maximum value of arr
    if num_bins == 1:
        return array filled with Y (same shape as arr)
    bins = generate num_bins+1 equally spaced points from Y to X
    bin_indices = find which bin each element belongs to (1-based index)
    bin_indices = bin_indices - 1  # convert to 0-based
    bin_values = upper bounds of each bin (bins[1:])
    quantized_arr = map each element to bin_values[bin_indices]
    return quantized_arr

2的幂次分箱（整数）伪代码 #

function quantize_power_of_two_int(arr, k):
    num_bins = 2^k
    Y = minimum value of arr
    X = maximum value of arr
    range_val = X - Y
    if num_bins == 1:
        return array filled with Y (same shape as arr)
    shift_bits = bit_length(range_val + 1) - 1 - k
    indices = (arr - Y) shifted right by shift_bits
    quantized = Y + ((indices + 1) shifted left by shift_bits) - 1
    return quantized

内容的提问来源于stack exchange，提问作者Amir