Question

我有这段代码：

import numpy as np


def sigmoid(x):
    """
    Calculate sigmoid
    """
    return 1 / (1 + np.exp(-x))


x = np.array([0.5, 0.1, -0.2])
target = 0.6
learnrate = 0.5

weights_input_hidden = np.array([[0.5, -0.6],
                                 [0.1, -0.2],
                                 [0.1, 0.7]])

weights_hidden_output = np.array([0.1, -0.3])

## Forward pass
hidden_layer_input = np.dot(x, weights_input_hidden)
hidden_layer_output = sigmoid(hidden_layer_input)

output_layer_in = np.dot(hidden_layer_output, weights_hidden_output)
output = sigmoid(output_layer_in)

## Backwards pass
## TODO: Calculate error
error = target - output

# TODO: Calculate error gradient for output layer
del_err_output = error * output * (1 - output)
print("del_err_output", del_err_output)

# TODO: Calculate error gradient for hidden layer
del_err_hidden = np.dot(del_err_output, weights_hidden_output) * hidden_layer_output * (1 - hidden_layer_output)
print("del_err_hidden", del_err_hidden)
print("del_err_hidden.shape", del_err_hidden.shape)
print("x", x)
print("x.shape", x.shape)
print("x[:,None]")
print(x[:,None])
print("x[:,None].shape", x[:,None].shape)
print("del_err_hidden * x[:, None]")
print(del_err_hidden * x[:, None])

生成此输出：

del_err_output 0.0287306695435
del_err_hidden [ 0.00070802 -0.00204471]
del_err_hidden.shape (2,)
x [ 0.5  0.1 -0.2]
x.shape (3,)
x[:,None]
[[ 0.5]
 [ 0.1]
 [-0.2]]
x[:,None].shape (3, 1)
del_err_hidden * x[:, None]
[[  3.54011093e-04  -1.02235701e-03]
 [  7.08022187e-05  -2.04471402e-04]
 [ -1.41604437e-04   4.08942805e-04]]

我的问题在于此操作：del_err_hidden * x[:, None]

哪种操作是*？

第二，如果del_err_hidden.shape是（2，）而x[:,None].shape是（3,1），为什么我可以将它们相乘？

有人告诉我，这与元素和广播有关，但我不理解这些术语。因为要进行元素乘法，所以两个矩阵必须具有相同的大小，并且在这里它们没有它。

Answer 1

*只是元素乘法。广播是它工作的原因。简而言之，当您使用一行大小（2，）（我们称之为 y ）将您的大小（3,1）（我们称之为 x ）的列重叠时，numpy创建一个新的3X2数组，其中第一列为y[0]*x，第二列为y[1]*x。

何时以及如何发生的确切规则有些复杂。有关详细信息，请参阅documentation

Answer 2

好的，我引用了文档中的broadcasting rules：

左侧有两个尺寸兼容 1）他们是平等的，或者是 2）其中一个是1

您有两个形状(2, )和(3, 1)数组。

arr1 (1D) shape :      2
arr2 (2D) shape :  3 x 1

#                      ^
#                      |    (c.f. rule-2)

In [24]: err              # shape (2,)
Out[24]: array([2, 4])

In [26]: x                # shape (3, 1)
Out[26]: 
array([[3],
       [4],
       [5]])

由于其中一个数组维度为1，因此会传递规则。这些阵列是可播放的，可以相乘。下一部分是拉伸从err成为的数组，（仅在概念上）。

In [27]: err          # shape (3, 2)
Out[27]: 
array([[2, 4],
       [2, 4],
       [2, 4]])

具有形状（2，）和（3,1）的向量相乘

2 个答案: