python - numpy 一维数组是否遵循行/列规则？

Question

我刚开始使用 numpy，我对如何使用数组感到困惑。我在 numpy 数组上看到了几个 Stack Overflow 的答案，但它们都涉及如何获得所需的结果(我知道如何做到这一点，我只是不知道为什么我需要这样做)。我所看到的共识是数组比矩阵更好，因为它们是更基本的类并且限制更少。我知道你可以转置一个数组，这对我来说意味着行和列之间存在区别，但乘法规则都会产生错误的输出(与我所期望的相比)。

这是我编写的测试代码以及​​输出:

a = numpy.array([1,2,3,4])
print(a)
>>> [1 2 3 4]

print(a.T)          # Transpose
>>> [1 2 3 4]       # No apparent affect

b = numpy.array( [ [1], [2], [3], [4] ] )
print(b)
>>> [[1]
     [2]
     [3]
     [4]]           # Column (Expected)

print(b.T)
>>> [[1 2 3 4]]     # Row (Expected, transpose seems to work here)

print((b.T).T)
>>> [[1]
     [2]
     [3]
     [4]]           # Column (All of these are as expected, 
                    #          unlike for declaring the array as a row vector)

# The following are element wise multiplications of a
print(a*a)
>>> [ 1  4  9 16]

print(a * a.T)      # Row*Column
>>> [ 1  4  9 16]   # Inner product scalar result expected

print(a.T * a)      # Column*Row
>>> [ 1  4  9 16]   # Outer product matrix result expected

print(b*b)
>>> [[1]
     [4]
     [9]
     [16]]          # Expected result, element wise multiplication in a column

print(b * b.T)      # Column * Row (Outer product)
>>> [[ 1  2  3  4]
     [ 2  4  6  8]
     [ 3  6  9 12]
     [ 4  8 12 16]] # Expected matrix result

print(b.T * (b.T))  # Column * Column (Doesn't make much sense so I expected elementwise multiplication
>>> [[ 1  4  9 16]]

print(b.T * (b.T).T) # Row * Column, inner product expected
>>> [[ 1  2  3  4]
    [ 2  4  6  8]
    [ 3  6  9 12]
    [ 4  8 12 16]]  # Outer product result

我知道我可以使用 numpy.inner() 和 numpy.outer() 来实现效果(这不是问题)，我只是想知道我是否需要跟踪我的向量是行还是列。

我还知道我可以创建一个一维矩阵来表示我的向量，并且乘法会按预期进行。我正在尝试找出存储数据的最佳方式，以便在查看代码时清楚将要发生什么 - 现在数学看起来很困惑且错误。

我的应用程序只需要使用一维和二维张量。

Answer 1

我会尝试注释您的代码

a = numpy.array([1,2,3,4])
print(a)
>>> [1 2 3 4]

print(a.T)          # Transpose
>>> [1 2 3 4]       # No apparent affect

a.shape 将显示 (4,)。 a.T.shape 是一样的。它保持相同的维数，并执行唯一有意义的转置——没有变化。使其成为 (4,1) 会增加一个维度，并破坏 A.T.T 往返。

b = numpy.array( [ [1], [2], [3], [4] ] )
print(b)
>>> [[1]
     [2]
     [3]
     [4]]           # Column (Expected)

print(b.T)
>>> [[1 2 3 4]]     # Row (Expected, transpose seems to work here)

b.shape是(4,1)，b.T.shape是(1,4)。注意额外的一组 []。如果您将 a 创建为 a = numpy.array([[1,2,3,4]])，它的形状也将是 (1 ,4)。

制作 b 的简单方法是 b=np.array([[1,2,3,4]]).T(或 b=np.array([1,2,3,4])[:,None] 或 b=np.array([1,2,3,4]).reshape(-1 ,1))

将其与 MATLAB 进行比较

octave:3> a=[1,2,3,4]
a =
   1   2   3   4
octave:4> size(a)
ans =
   1   4
octave:5> size(a.')
ans =
   4   1

即使没有额外的 []，它也会将矩阵初始化为 2d。

numpy 有一个模仿 MATLAB 的 matrix 类 - 在 MATLAB 只允许 2d 的时候。

In [75]: m=np.matrix('1 2 3 4')

在 [76] 中:m Out[76]: 矩阵([[1, 2, 3, 4]])

In [77]: m.shape
Out[77]: (1, 4)

In [78]: m=np.matrix('1 2; 3 4')

In [79]: m
Out[79]: 
matrix([[1, 2],
        [3, 4]])

我不建议使用 np.matrix 除非它真的可以为您的代码添加一些有用的东西。

请注意 MATLAB 中关于向量 的讨论，但它们实际上只是它们的矩阵，只有一个非单一维度。

# The following are element wise multiplications of a
print(a*a)
>>> [ 1  4  9 16]

print(a * a.T)      # Row*Column
>>> [ 1  4  9 16]   # Inner product scalar result expected

此行为遵循 a.T == A。正如您所指出的，* 产生逐个元素的乘法。这等效于 MATLAB .*。 np.dot(a,a) 给出 2 个数组的点积或矩阵积。

print(a.T * a)      # Column*Row
>>> [ 1  4  9 16]   # Outer product matrix result expected

不，它仍在进行元素乘法。

我会使用广播，a[:,None]*a[None,:] 来获得外积。 Octave 模仿 numpy 添加了这个；不知道 MATLAB 有没有。

在下面的* 中总是逐个元素相乘。产生矩阵/外积结果的是广播。

print(b*b)
>>> [[1]
     [4]
     [9]
     [16]]          # Expected result, element wise multiplication in a column

(4,1) * (4,1)=>(4,1)。四周形状相同。

print(b * b.T)      # Column * Row (Outer product)
>>> [[ 1  2  3  4]
     [ 2  4  6  8]
     [ 3  6  9 12]
     [ 4  8 12 16]] # Expected matrix result

此处 (4,1)*(1,4)=>(4,4) 产品。 2 个大小的 1 维度已被复制，因此它实际上变成了 (4,4)*(4,4)。您将如何在 MATLAB 中复制它 - 使用 .*？

print(b.T * (b.T))  # Column * Column (Doesn't make much sense so I expected elementwise multiplication
>>> [[ 1  4  9 16]]

* 是按元素排列的，与预期无关。在 MATLAB 中思考 b' .* b'。

print(b.T * (b.T).T) # Row * Column, inner product expected
>>> [[ 1  2  3  4]
    [ 2  4  6  8]
    [ 3  6  9 12]
    [ 4  8 12 16]]  # Outer product result

同样 * 是逐元素的； inner 除了乘法之外还需要求和。这里广播再次应用 (1,4)*(4,1)=>(4,4)。

np.dot(b,b) 或 np.trace(b.T*b) 或 np.sum(b*b)给出 30。

当我在 MATLAB 工作时，我经常检查 size，并创建测试矩阵来捕获维度不匹配(例如 2x3 而不是 2x2 矩阵)。我继续在 numpy 中这样做。

关键是:

• numpy 数组可能是 1d(甚至 0d)

• (4,) 数组与 (4,1) 或 (1,4)` 不完全相同。

• * 始终是元素级的。

• 广播通常会解释外部类行为