Python Numpy数组、索引和卷积混淆

我试图完成以下函数，但在索引方面遇到问题，导致“ValueError:操作数无法与形状（0,9）（5）一起广播”

我想我的错误可能是因为我试图调用ssd_difference[]中的值，但我不能完全确定

根据下面给出的提示，我将如何使用convolve2d？我知道numpy有它的功能，但我不知道我需要投入什么才能让它工作

附加信息：binomialFilter5（）返回一个5x1 numpy的数据类型浮点数组，表示一个二项式过滤器。我还假设“权重[]”是ssd_差[]值

def transitionDifference(ssd_difference):

“”“计算帧之间的转换成本，将动力学考虑在内 帐户

说明： 1.遍历ssd difference的行和列，忽略 前两个值和后两个值。
1a.对于i，j处的每个值，乘以长度的二项式滤波器 五（在代码后面实现）由两个开始的权重 前两帧到后两帧，取它们的和 产品

            i.e. Your weights for frame i are:
                 [weight[i - 2, j - 2],
                  weight[i - 1, j - 1],
                  weight[i, j],
                  weight[i + 1, j + 1],
                  weight[i + 2, j + 2]]

将其乘以每个i，j处的二项式滤波器权重，得到 您的输出

可能需要一点理解才能理解我们为什么会这样 计算这个，简单的解释是 第4帧到第5帧，我们称之为ch（4，5），我们制作这个权重：

ch（4,5）=ch（2,3）+ch（3,4）+ch（4,5）+ch（5,6）+ch（6,7）

这说明了以前更改和未来更改中的权重 在考虑当前帧时发生更改

当然，我们通过二项式滤波器对所有这些和进行加权，所以 权重ch（4，5）仍然是最重要的，但是 希望这能让你更好地理解

Args:
    ssd_difference (numpy.ndarray): A difference matrix as produced by your
                                    ssd function.

Returns:
    output (numpy.ndarray): A difference matrix that takes preceding and
                            following frames into account. The output
                            difference matrix should have the same dtype as
                            the input, but be 4 rows and columns smaller,
                            corresponding to only the frames that have valid
                            dynamics.

Hint: There is an efficient way to do this with 2d convolution. Think about
      the coordinates you are using as you consider the preceding and
      following frame pairings.
"""

output = np.zeros((ssd_difference.shape[0] - 4,
                   ssd_difference.shape[1] - 4), dtype=ssd_difference.dtype)
# WRITE YOUR CODE HERE.
for i in range(len(ssd_difference)):
    for j in range(len(ssd_difference)):
        if i == 0:
            if j > 1:
                output[i,j] = np.sum( ssd_difference[i-2:i+2]*binomialFilter5())
        elif i == ssd_difference.shape[0] - 1:
            if j < ssd_difference.shape[1] - 2:
                output[i,j] = np.sum( ssd_difference[i-2:i+2]*binomialFilter5())
        else:
            output[i,j] = np.sum( ssd_difference[i-2:i+2]*binomialFilter5())
# END OF FUNCTION.
return output

Args:
ssd_差异（numpy.ndarray）：由您的
ssd功能。
返回：
输出（numpy.ndarray）：采用前置和后置格式的差分矩阵
考虑以下帧。输出
差异矩阵的数据类型应与
输入，但要小4行和4列，
仅对应于具有有效属性的帧
动力学。
提示：2d卷积是一种有效的方法。请考虑
当你考虑前面和你使用的坐标时
下面是框架对。
"""
输出=np.零（（ssd_差分形状[0]-4，
ssd_difference.shape[1]-4），dtype=ssd_difference.dtype）
#在这里编写代码。
对于范围内的i（len（ssd_差））：
对于范围内的j（len（ssd_差））：
如果i==0：
如果j>1：
输出[i，j]=np.sum（ssd_差[i-2:i+2]*binomialFilter5（））
elif i==ssd_差异。形状[0]-1：
如果j

正如我所评论的，您真的应该告诉我们产生错误消息的那一行

但我可以猜测，因为只有几条线路可以进行涉及广播的操作。很可能是：

output[i,j] = np.sum( ssd_difference[i-2:i+2]*binomialFilter5())

您编写的

binomialFilter5（）

生成一个

（5,1）

数组，但该错误涉及

（5，）

。这在这里可能不重要，但是你真的应该保持维度的数量。有时

（5,1）

与

（5,1）

有显著不同

输出

具有形状

（ssd_差异。形状[0]-4，ssd_差异。形状[1]-4）

。但是您在

范围（len（ssd_差异））

上迭代

i，j

<代码>输出[i，j]最终将导致

索引错误

。尤其是在迭代二维数组时，最好使用正确的

shape

元素，而不是

len（）

但是我怀疑直接的错误是由于ssd的差异[I-2:I+2]造成的。当

i==0

时，这是

ssd\u差[-2:2]

。这将生成

（0,9）

数组，因为

-2

索引表示距离最后一个的第二个，它大于

2

我认为您打算从这个数组中提取5行，以匹配另一个数组中的5个值。我认为正确的迭代是：

for i in range(output.shape[0]):
    for j in range(output.shape[1]):
       ....
       output[i,j] = np.sum(ssd_difference[i:i+5, :] * binomialFilter5())
       ...

---

您应该在交互式shell中单独测试这样的表达式，选择值为

i

ssd_差异[i:i+5，：]

应具有形状

（5,9）

，

binomialFilter5（）

应为

（5,1）

显示更多的

值错误

，特别是标有

----

的行。请关注具有

形状（0,9）（5）

的操作数，以及尝试组合它们的

操作是什么。对不起，这行输出[i，j]=np.sum（ssd_difference[i-2:i+2]*binomialFilter5（））我知道我不能将不同大小的矩阵相乘，但是我想不出任何其他方法来实现函数的目的（至少根据说明）。这是有意义的，非常感谢！很抱歉，没有包含错误所指向的行。仍在努力学习正确的代码/堆栈溢出礼仪。只是向可能有类似问题的任何人提供更新。transpose（）是您的朋友。