Python：将for循环操作扩展到矩阵中的每一行，而不使用迭代

我有一段代码如下：

a = Y[0]; b = Z[0]
print(a, b)
loss = 0
for i in range(len(a)):
    k = len(a)-i
    loss += (2**(k-1))*np.abs(a[i]-b[i])
print(loss)

for j in range(Y.shape[0]):
    a = Y[j]; b = Z[j]
    loss = 0
    for i in range(len(a)):
        k = len(a)-i
        loss += (2**(k-1))*np.abs(a[i]-b[i])
    print(loss)

其中，

Y

和

Z

为尺寸

250 x 10

，每行为10位二进制值。例如，

print（a，b）

打印以下内容：

[1 0 0 0 0 0 0 1 0][0 0 0 0 0 0 1 1 1 1 0 0]

现在我想在for循环中为

Y

和

Z

之间的对应行应用两行函数。但我不想做这样的事情：

a = Y[0]; b = Z[0]
print(a, b)
loss = 0
for i in range(len(a)):
    k = len(a)-i
    loss += (2**(k-1))*np.abs(a[i]-b[i])
print(loss)

for j in range(Y.shape[0]):
    a = Y[j]; b = Z[j]
    loss = 0
    for i in range(len(a)):
        k = len(a)-i
        loss += (2**(k-1))*np.abs(a[i]-b[i])
    print(loss)

---

我基本上是在keras/tensorflow中创建一个自定义损失函数。对于循环例子来说，对于大张量运算，它是不可伸缩的。如何使用某种批处理矩阵操作来代替for循环？

如果只需要将内部循环进行numpy并行化：

将numpy导入为np
对于范围内的j（Y.形状[0]）：
a=Y[j]；b=Z[j]
损失=0
"""
对于范围内的i（len（a））：
k=len（a）-i
损失+=（2**（k-1））*np.abs（a[i]-b[i]）
"""
k=np.arange（len（a），0，-1）
损失=np.和（np.乘（2**（k-1），np.绝对值（a-b）））
打印（丢失）

编辑

要使其更加numpy并行化，请使用以下方法：

将numpy导入为np
#此函数用于计算行对的损失
def get_损失（世界其他地区，深圳）：
损失=0
k=np.arange（sz，0，-1）
损失=np.总和（np.乘法（2**（k-1），np.绝对值（行[：sz]-行[sz:]））
回波损耗
#样本输入矩阵
A=np.随机.随机（（5，10））
B=np.随机.随机（（5,10））
#连接输入矩阵
AB=np.连接（（A，B），轴=1）
#在每一行对上应用该函数
结果=np。沿_轴应用_（获取_损失，1，AB，A.形状[1]）
#结果是损失的一维数组
打印（结果.形状）

您可以这样做：

factor = 2**np.arange(Y.shape[1])[::-1]
loss = np.sum(factor * np.abs(Y-Z), axis=-1)

---

到Y和Z之间的每对行

-您只对对应的一对行执行操作，对吗？是否希望最终计算的

损失

为向量（其长度等于从

Y

和

Z

中选择的对数）？或者，你想把

损失

进一步减少到一个标量吗？对不起，我应该在我的帖子中澄清一下。我需要相应的行。例如，如果我执行

Z=Y

，然后运行您的代码，我应该得到0。@Jonathan--相应地编辑了我的答案。现在更简单了。@Jonathan-我现在编辑了答案，提供了

250

损失值的向量。请在验证后确认这是否是您想要的。回答的时间：

20.5µs±4.21µs/循环（平均±标准偏差为7次，每个循环10000次）

。而我所建议的方法时间：

210µs±32.3µs/循环（7次运行的平均值±标准偏差，每个循环1000次）

。荣誉连接是一个稍微昂贵的操作，因为它需要将数组数据复制到新创建的数组的新内存位置。您可以将它们作为两个单独的数组传递，并在函数内部适当地访问它们，而不是连接。（在任何情况下，您似乎要在函数内分别访问连接数组的两部分）我想使用

np.apply\u沿_轴

。如果没有concat，第二个matrx将需要索引，超出目的！