numpy：如何从矩阵向量构造向量矩阵

Question

I'm new to numpy, so, with numpy, is it possible to use a vector of matrix to get a matrix of vectors" for example:

matrix1(  
[  
 [1, 2, 3],  
 [1, 2, 3],  
 [1, 2, 3]  
])

matrix2(  
[  
 [2, 4, 6],  
 [2, 4, 6],  
 [2, 4, 6]  
])

-->

matrix(  
[  
 [array('1 2'), array('2 4'), array('3 6')],  
 [array('1 2'), array('2 4'), array('3 6')],  
 [array('1 2'), array('2 4'), array('3 6')]  
])

I'm new to numpy, so I'm not sure if it is allowed to put any thing in numpy's matrix or just numbers. And it's not easy to get answer from google with descriptions like "matrix of vectors and vectors of matrix"

Answer 1

numpy doesn't have a concept of "vector" separate from "matrix." It does have distinct concepts of "matrix" and "array," but most people avoid the matrix representation entirely. If you use arrays, the concepts of "vector," "matrix," and "tensor" are all subsumed under the general concept of an array's "shape" attribute.

In this worldview, vectors and matrices are both 2-dimensional arrays, distinguished only by their shape. Row vectors are arrays with the shape (1, n) , while column vectors are arrays with the shape (n, 1) . Matrices are arrays with the shape (n, m) . 1-dimensional arrays can behave like vectors sometimes, depending on context, but often you'll find that you won't get what you want unless you "upgrade" them.

With all that in mind, here's one possible answer to your question. First, we create a 1-d array:

>>> a1d = numpy.array([1, 2, 3])
>>> a1d
array([1, 2, 3])

Now we reshape it to create a column vector. The -1 here tells numpy to figure out the right size given the input.

>>> vcol = a1d.reshape((-1, 1))
>>> vcol
array([[1],
       [2],
       [3]])

Observe the doubled brackets at the beginning and ending of this. That's a subtle cue that this is a 2-d array, even though one dimension has a size of just 1.

We can do the same thing, swapping the dimensions, to get a row. Note again the doubled brackets.

>>> vrow = a1d.reshape((1, -1))
>>> vrow
array([[1, 2, 3]])

You can tell that these are 2-d arrays, because a 1-d array would have only one value in its shape tuple:

>>> a1d.shape
(3,)
>>> vcol.shape
(3, 1)
>>> vrow.shape
(1, 3)

To build a matrix from column vectors we can use hstack . There are lots of other methods that may be faster, but this is a good starting point. Here, note that [vcol] is not a numpy object, but an ordinary python list, so [vcol] * 3 means the same thing as [vcol, vcol, vcol] .

>>> mat = numpy.hstack([vcol] * 3)
>>> mat
array([[1, 1, 1],
       [2, 2, 2],
       [3, 3, 3]])

And vstack gives us the same thing from row vectors.

>>> mat2 = numpy.vstack([vrow] * 3)
>>> mat2
array([[1, 2, 3],
       [1, 2, 3],
       [1, 2, 3]])

It's unlikely that any other interpretation of "construct a matrix of vectors from vector of matrix" will generate something you actually want in numpy !

Since you mention wanting to do linear algebra, here are a couple of operations that are possible. This assumes you're using a recent-enough version of python to use the new @ operator, which provides an unambiguous inline notation for matrix multiplication of arrays. ¹

For arrays, multiplication is always element-wise. But sometimes there is broadcasting. For values with the same shape, it's plain element-wise multiplication:

>>> vrow * vrow
array([[1, 4, 9]])
>>> vcol * vcol
array([[1],
       [4],
       [9]])

When values have different shapes, they are broadcast together if possible to produce a sensible result:

>>> vrow * vcol
array([[1, 2, 3],
       [2, 4, 6],
       [3, 6, 9]])
>>> vcol * vrow
array([[1, 2, 3],
       [2, 4, 6],
       [3, 6, 9]])

Broadcasting works in the way you'd expect for other shapes as well:

>>> vrow * mat
array([[1, 2, 3],
       [2, 4, 6],
       [3, 6, 9]])
>>> vcol * mat
array([[1, 1, 1],
       [4, 4, 4],
       [9, 9, 9]])

If you want a dot product, you have to use the @ operator:

>>> vrow @ vcol
array([[14]])

Note that unlike the * operator, this is not symmetric:

>>> vcol @ vrow
array([[1, 2, 3],
       [2, 4, 6],
       [3, 6, 9]])

This can be a bit confusing at first, because this looks the same as vrow * vcol , but don't be fooled. * will produce the same result regardless of argument order. Finally, for a matrix-vector product:

>>> mat @ vcol
array([[ 6],
       [12],
       [18]])

Observe again the difference between @ and * :

>>> mat * vcol
array([[1, 1, 1],
       [4, 4, 4],
       [9, 9, 9]])

_{1. Sadly, this only exists as of Python 3.5. If you need to work with an earlier version, all the same advice applies, except that instead of using inline notation for a @ b , you have to use np.dot(a, b) . numpy 's matrix type overrides * to behave like @ ... but then you can't do element-wise multiplication or broadcasting the same way! So even if you have an earlier version, I don't recommend using the matrix type.}