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 /线性代数的某些基本特征？我不认为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如何确定列向量的尺寸？

1 个答案: