在numpy中，有些操作以形状(R, 1)返回，但有些返回(R，)。这将使矩阵乘法更加繁琐，因为需要显式重塑。例如，给定一个矩阵M，如果我们想要numpy。点(M [: 0], numpy。ones((1, R)))，其中R是行数(当然，列方面也存在同样的问题)。我们将得到矩阵不是对齐错误，因为M[:，0]是在形状(R，)，而是numpy。ones((1, R))的形状是(1,R)。
所以我的问题是:
形状(R, 1)和(R，)的区别是什么?我知道字面上它是一个数字的列表和列表的列表所有的列表都只包含一个数字。只是想知道为什么不设计numpy，使它更喜欢形状(R, 1)而不是(R，)，以便于矩阵乘法。 对于上面的例子有没有更好的方法?不需要像这样显式地重塑:numpy.dot(M[:，0]。重塑(R, 1)， numpy。((R)))
当前回答
这里已经有很多好的答案了。但对我来说，很难找到一些例子，形状或数组可以破坏所有的程序。
下面是一个例子:
import numpy as np
a = np.array([1,2,3,4])
b = np.array([10,20,30,40])
from sklearn.linear_model import LinearRegression
regr = LinearRegression()
regr.fit(a,b)
这将失败并产生错误:
ValueError:期望的2D数组，得到的是1D数组
但如果我们对a加上重塑:
a = np.array([1,2,3,4]).reshape(-1,1)
这是正确的!
其他回答
需要明确的是，我们谈论的是:
NumPy数组，也称为NumPy .ndarray 数组的形状，由numpy.ndarray.shape所知 这个问题假设了一些未知的numpy。形状为(R，)的ndarray，其中R应该理解为其各自维度的长度
NumPy数组有一个形状。这个.shape由一个元组表示，其中元组中的每个元素都告诉我们该维度的长度。为了保持简单，让我们坚持行和列。而numpy的值。Ndarray在下面的例子中不会改变，但形状会。
让我们考虑一个值为1、2、3和4的数组。
我们的例子将包括以下.shape表示:
(4,) # 1-dimensional array with length 4
(1,4) # 2-dimensional array with row length 1, column length 4
(4,1) # 2-dimensional array with row length 4, column length 1
我们可以更抽象地考虑变量a和b。
(a,) # 1-dimensional array with length a
(b,a) # 2-dimensional array with row length b, column length a
(a,b) # 2-dimensional array with row length a, column length b
对我来说，“手动”构建它们有助于更好地理解它们的维度含义。
>> # (4,)
>> one_dimensional_vector = np.array(
[1, 2, 3, 4]
)
>> # (1,4)
>> row_vector = np.array(
[
[1, 2, 3, 4]
]
)
>> # (4,1)
>> column_vector = np.array(
[
[1],
[2],
[3],
[4]
]
)
第一个问题的答案是
形状(R, 1)和形状(R，)的区别是什么?
答:它们有不同的维度。A是一个维度的长度，b是另一个维度的长度，.shape分别是(A, b)和(A，)。B恰好是1。一种考虑方法是，如果a = 1，那么行长度为1，因此它是行向量。如果b = 1，则该列的长度为1，因此numpy。它表示的Ndarray是一个列向量。
对于上面的例子有没有更好的方法?
回答:让我们假设我们有上面示例中使用的数组，其中1、2、3和4为值。使(R，)为(R, 1)的简便方法是:
>> one_dimensional_array = np.array([1,2,3,4])
>> one_dimensional_array.shape
(4,)
>> row_vector = one_dimensional_array[:, None]
>> row_vector.shape
(4, 1)
资源
NumPy - ndarrays - https://numpy.org/doc/stable/reference/arrays.ndarray.html 交叉验证@unutbu -维戏法- https://stats.stackexchange.com/a/285005
这里已经有很多好的答案了。但对我来说，很难找到一些例子，形状或数组可以破坏所有的程序。
下面是一个例子:
import numpy as np
a = np.array([1,2,3,4])
b = np.array([10,20,30,40])
from sklearn.linear_model import LinearRegression
regr = LinearRegression()
regr.fit(a,b)
这将失败并产生错误:
ValueError:期望的2D数组，得到的是1D数组
但如果我们对a加上重塑:
a = np.array([1,2,3,4]).reshape(-1,1)
这是正确的!
形状是一个元组。如果只有一个维度，形状将是一个数字，逗号后是空白。对于2+维度，所有的逗号后面会有一个数字。
# 1 dimension with 2 elements, shape = (2,).
# Note there's nothing after the comma.
z=np.array([ # start dimension
10, # not a dimension
20 # not a dimension
]) # end dimension
print(z.shape)
(2)
# 2 dimensions, each with 1 element, shape = (2,1)
w=np.array([ # start outer dimension
[10], # element is in an inner dimension
[20] # element is in an inner dimension
]) # end outer dimension
print(w.shape)
(2, 1)
1. NumPy中形状的含义
你写，“我知道字面上它是一个数字的列表，所有的列表都只包含一个数字”，但这是一种没有帮助的思考方式。
考虑NumPy数组的最佳方式是，它们由两部分组成，一个数据缓冲区(只是一个原始元素块)和一个描述如何解释数据缓冲区的视图。
例如，如果我们创建一个包含12个整数的数组:
>>> a = numpy.arange(12)
>>> a
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
a由一个数据缓冲区组成，它的排列方式如下:
┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│ 0 │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 10 │ 11 │
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘
以及描述如何解释数据的视图:
>>> a.flags
C_CONTIGUOUS : True
F_CONTIGUOUS : True
OWNDATA : True
WRITEABLE : True
ALIGNED : True
UPDATEIFCOPY : False
>>> a.dtype
dtype('int64')
>>> a.itemsize
8
>>> a.strides
(8,)
>>> a.shape
(12,)
这里的形状(12，)表示数组由一个从0到11的索引索引。从概念上讲，如果我们把这个索引标为i，数组a看起来就像这样:
i= 0 1 2 3 4 5 6 7 8 9 10 11
┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│ 0 │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 10 │ 11 │
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘
如果我们重塑一个数组，这不会改变数据缓冲区。相反，它创建了一个新视图，该视图描述了解释数据的不同方式。后:
>>> b = a.reshape((3, 4))
数组b拥有与a相同的数据缓冲区，但现在它由两个索引组成，分别从0到2和从0到3。如果我们把两个下标标为i和j，数组b看起来就像这样:
i= 0 0 0 0 1 1 1 1 2 2 2 2
j= 0 1 2 3 0 1 2 3 0 1 2 3
┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│ 0 │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 10 │ 11 │
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘
这意味着:
>>> b[2,1]
9
您可以看到第二个索引变化很快，而第一个索引变化缓慢。如果你想反过来，你可以指定order参数:
>>> c = a.reshape((3, 4), order='F')
结果是数组的索引是这样的:
i= 0 1 2 0 1 2 0 1 2 0 1 2
j= 0 0 0 1 1 1 2 2 2 3 3 3
┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│ 0 │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 10 │ 11 │
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘
这意味着:
>>> c[2,1]
5
现在应该清楚数组具有一个或多个尺寸为1的形状意味着什么了。后:
>>> d = a.reshape((12, 1))
数组d由两个下标组成，第一个下标从0到11，第二个下标总是0:
i= 0 1 2 3 4 5 6 7 8 9 10 11
j= 0 0 0 0 0 0 0 0 0 0 0 0
┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│ 0 │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 10 │ 11 │
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘
所以:
>>> d[10,0]
10
长度为1的维度是“自由的”(在某种意义上)，所以没有什么可以阻止你去镇上:
>>> e = a.reshape((1, 2, 1, 6, 1))
给出一个这样的数组索引:
i= 0 0 0 0 0 0 0 0 0 0 0 0
j= 0 0 0 0 0 0 1 1 1 1 1 1
k= 0 0 0 0 0 0 0 0 0 0 0 0
l= 0 1 2 3 4 5 0 1 2 3 4 5
m= 0 0 0 0 0 0 0 0 0 0 0 0
┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐
│ 0 │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 10 │ 11 │
└────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘
所以:
>>> e[0,1,0,0,0]
6
有关如何实现数组的更多细节，请参阅NumPy内部文档。
2. 怎么办呢?
因为numpy。重塑只是创建了一个新的视图，你不应该害怕在任何必要的时候使用它。当你想以不同的方式索引一个数组时，它是一个合适的工具。
然而，在长时间的计算中，通常可以在一开始就安排构造具有“正确”形状的数组，从而最大限度地减少重塑和转置的数量。但在没有看到导致需要重塑的实际背景之前，很难说应该改变什么。
你问题中的例子是:
numpy.dot(M[:,0], numpy.ones((1, R)))
但这是不现实的。首先，这个表达式:
M[:,0].sum()
计算结果更简单。第二，列0真的有什么特别之处吗?也许你真正需要的是:
M.sum(axis=0)
对于其基数组类，2d数组并不比1d或3d数组更特殊。有些操作保留维度，有些操作减少维度，有些操作合并甚至扩展维度。
M=np.arange(9).reshape(3,3)
M[:,0].shape # (3,) selects one column, returns a 1d array
M[0,:].shape # same, one row, 1d array
M[:,[0]].shape # (3,1), index with a list (or array), returns 2d
M[:,[0,1]].shape # (3,2)
In [20]: np.dot(M[:,0].reshape(3,1),np.ones((1,3)))
Out[20]:
array([[ 0., 0., 0.],
[ 3., 3., 3.],
[ 6., 6., 6.]])
In [21]: np.dot(M[:,[0]],np.ones((1,3)))
Out[21]:
array([[ 0., 0., 0.],
[ 3., 3., 3.],
[ 6., 6., 6.]])
给出相同数组的其他表达式
np.dot(M[:,0][:,np.newaxis],np.ones((1,3)))
np.dot(np.atleast_2d(M[:,0]).T,np.ones((1,3)))
np.einsum('i,j',M[:,0],np.ones((3)))
M1=M[:,0]; R=np.ones((3)); np.dot(M1[:,None], R[None,:])
MATLAB从2D数组开始。新版本允许更多维度，但保留了2的下界。但是你还是要注意行矩阵和列矩阵之间的区别，列矩阵的形状是(1,3)v (3,1)你多久写一次[1,2,3]?我要写行向量和列向量，但是有了二维的约束，在MATLAB中没有任何向量至少在数学意义上的向量是一维的。
你看过np吗?至少2d(也_1d和_3d版本)?
在新的Python/numpy中，有一个matmul操作符
In [358]: M[:,0,np.newaxis]@np.ones((1,3))
Out[358]:
array([[0., 0., 0.],
[3., 3., 3.],
[6., 6., 6.]])
在numpy中，元素乘法在某种意义上比矩阵乘法更基本。对于大小为1的积和，不需要使用dot/matmul:
In [360]: M[:,0,np.newaxis]*np.ones((1,3))
Out[360]:
array([[0., 0., 0.],
[3., 3., 3.],
[6., 6., 6.]])
它使用广播，这是numpy一直拥有的强大功能。MATLAB最近才添加了它。
