无法通过嵌套循环计算指定求和值，求优化实现逻辑

现有定义 #

给定二进制向量数组和函数f：

import numpy as np

binary_values =[[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1], [1, 0, 0], [1, 0, 1], [1, 1, 0], [1, 1, 1]]

def f(x):
    m = np.matrix([0.5,-0.5, 0.3])
    w = m.transpose()
    Y = np.dot(x,w)
    return Y

需求：计算三组特征位求和 #

需要针对二进制向量的第0、1、2位分别计算以下求和：

1. 第0位为1的情况：

   (f([1,0,0])-f([0,0,0])) + (f([1,0,1])-f([0,0,1])) + (f([1,1,0])-f([0,1,0])) + (f([1,1,1])-f([0,1,1]))
   

2. 第1位为1的情况：

   (f([0,1,0])-f([0,0,0])) + (f([0,1,1])-f([0,0,1])) + (f([1,1,0])-f([1,0,0])) + (f([1,1,1])-f([1,0,1]))
   

3. 第2位为1的情况：

   (f([0,0,1])-f([0,0,0])) + (f([0,1,1])-f([0,1,0])) + (f([1,0,1])-f([1,0,0])) + (f([1,1,1])-f([1,1,0]))
   

原尝试代码的问题 #

原代码存在核心逻辑错误：

• 循环中i是数组内的向量元素，并非索引，binary_values[i][0]会触发索引异常
• 直接硬编码求和式，无复用性，且每次循环覆盖sum变量，最终仅能得到最后一组结果

优化实现方案 #

方案1：数学推导简化（最高效） #

先拆解f(x)的数学表达式：
f(x) = 0.5*x[0] - 0.5*x[1] + 0.3*x[2]

对任意特征位k，对比x（第k位为1）和x'（第k位为0、其余位相同）时，f(x)-f(x')等于对应权重值：

• 第0位：每个项为0.5，共4个项，总和为4*0.5 = 2
• 第1位：每个项为-0.5，总和为4*(-0.5) = -2
• 第2位：每个项为0.3，总和为4*0.3 = 1.2

直接计算的代码：

weights = np.array([0.5, -0.5, 0.3])
sums = [4 * w for w in weights]
print("三组求和结果：", sums)
# 输出：三组求和结果： [2.0, -2.0, 1.2]

方案2：通用遍历实现（扩展性强） #

如果后续权重或向量数组有变更，此方式无需修改核心逻辑：

import numpy as np

binary_values =[[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1], [1, 0, 0], [1, 0, 1], [1, 1, 0], [1, 1, 1]]

# 简化函数实现，无需转置矩阵
def f(x):
    m = np.array([0.5,-0.5, 0.3])
    return np.dot(x, m)

def calculate_sum_for_bit(bit_index):
    total = 0.0
    for vec in binary_values:
        if vec[bit_index] == 1:
            # 生成对应位为0的向量
            vec_zero = vec.copy()
            vec_zero[bit_index] = 0
            total += f(vec) - f(vec_zero)
    return total

# 计算三组求和
sum_bit0 = calculate_sum_for_bit(0)
sum_bit1 = calculate_sum_for_bit(1)
sum_bit2 = calculate_sum_for_bit(2)

print(f"第0位求和结果：{sum_bit0}")
print(f"第1位求和结果：{sum_bit1}")
print(f"第2位求和结果：{sum_bit2}")

输出结果：

第0位求和结果：2.0
第1位求和结果：-2.0
第2位求和结果：1.2

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