numpy 如何确定列向量的维度？

Question

我从 numpy 开始，并试图弄清楚它的数组如何用于列向量。定义如下：

x1 = np.array([3.0, 2.0, 1.0])
x2 = np.array([-2.0, 1.0, 0.0])

并调用

print("inner product x1/x2: ", np.inner(x1, x2))

按预期生成 inner product x1/x2: -4.0 - 这让我觉得 numpy 假设这种形式的数组是一个列向量，并且作为内部函数的一部分，将其中一个转置为一个标量。然而，我写了一些代码来测试这个想法，它给出了一些我不明白的结果。

在使用谷歌搜索如何使用 .T 指定数组是列向量后，我定义了以下内容：

x = np.array([1, 0]).T
xT = np.array([1, 0])

我打算让 x 成为列向量，xT 成为行向量。但是，调用以下内容：

print(x)
print(x.shape)

print(xT)
print(xT.shape)

产生这个：

[1 0]
(2,)
[1 0]
(2,)

这表明这两个数组具有相同的维度，尽管一个数组是另一个数组的转置。此外，同时调用 np.inner(x,x) 和 np.inner(x,xT) 会产生相同的结果。我是不是误解了 .T 函数，或者 numpy/linear 代数的一些基本特征？我觉得 x 和 xT 不应该是同一个向量。

最后，我最初使用 .T 的原因是因为尝试将列向量定义为 x = np.array([[1], [0]]) 并调用 print(np.inner(x, x)) 产生以下内积：

[[1 0]
 [0 0]]

这是您希望看到的外积的输出。我是否误用了这种定义列向量的方式？

Answer 1

查看 inner 文档：

Ordinary inner product of vectors for 1-D arrays 
...
np.inner(a, b) = sum(a[:]*b[:])

使用您的示例数组：

In [374]: x1 = np.array([3.0, 2.0, 1.0]) 
     ...: x2 = np.array([-2.0, 1.0, 0.0])                                       
In [375]: x1*x2                                                                 
Out[375]: array([-6.,  2.,  0.])
In [376]: np.sum(x1*x2)                                                         
Out[376]: -4.0
In [377]: np.inner(x1,x2)                                                       
Out[377]: -4.0
In [378]: np.dot(x1,x2)                                                         
Out[378]: -4.0
In [379]: x1@x2                                                                 
Out[379]: -4.0

来自 dot/scalar/inner product 的 wiki：

https://en.wikipedia.org/wiki/Dot_product

two equal-length sequences of numbers (usually coordinate vectors) and returns a single number

If vectors are identified with row matrices, the dot product can also 
be written as a matrix product

来自线性代数世界，很容易根据矩阵 (2d) 和向量来思考一切，它们是 1 行或 1 列矩阵。 MATLAB/Octave 在该框架中工作。但是 numpy 更通用，数组具有 0 维或更多维，而不仅仅是 2.

np.transpose 不添加维度，它只是排列现有维度。因此 x1.T 不会改变任何东西。

列向量可以用np.array([[1], [0]])或：

In [381]: x1                                                                    
Out[381]: array([3., 2., 1.])
In [382]: x1[:,None]                                                            
Out[382]: 
array([[3.],
       [2.],
       [1.]])
In [383]: x1.reshape(3,1)                                                       
Out[383]: 
array([[3.],
       [2.],
       [1.]])

np.inner 描述了当输入不是 1d 时会发生什么，例如你的 2d (2,1) 形状 x。它说它使用 np.tensordot，这是 np.dot 矩阵乘积的概括。

In [386]: x = np.array([[1],[0]])                                               
In [387]: x                                                                     
Out[387]: 
array([[1],
       [0]])
In [388]: np.inner(x,x)                                                         
Out[388]: 
array([[1, 0],
       [0, 0]])
In [389]: np.dot(x,x.T)                                                         
Out[389]: 
array([[1, 0],
       [0, 0]])
In [390]: x*x.T                                                                 
Out[390]: 
array([[1, 0],
       [0, 0]])

这是 (2,1) 和 (1,2) 的元素乘积，得到 (2,2) 或外积。

numpy 如何确定列向量的维度？

How does numpy determine the dimensions of a column vector?

arrays

numpy

shapes

numpy-ndarray