Transforming a row vector into a column vector in Numpy

Question

Let\'s say I have a row vector of the shape (1, 256). I want to transform it into a column vector of the shape (256, 1) instead. How would you do it in Numpy?

Answer 1

To convert a row vector into a column vector in Python can be important e.g. to use broadcasting:

import numpy as np

def colvec(rowvec):
    v = np.asarray(rowvec)
    return v.reshape(v.size,1)

colvec([1,2,3]) * [[1,2,3], [4,5,6], [7,8,9]]

Multiplies the first row by 1, the second row by 2 and the third row by 3:

array([[ 1,  2,  3],
       [ 8, 10, 12],
       [  21, 24, 27]])

In contrast, trying to use a column vector typed as matrix:

np.asmatrix([1, 2, 3]).transpose() * [[1,2,3], [4,5,6], [7,8,9]]

fails with error ValueError: shapes (3,1) and (3,3) not aligned: 1 (dim 1) != 3 (dim 0).

Answer 2

We can simply use the reshape functionality of numpy:

a=np.array([[1,2,3,4]])
a:
array([[1, 2, 3, 4]])

a.shape
(1,4)
b=a.reshape(-1,1)
b:
array([[1],
       [2],
       [3],
       [4]])

b.shape
(4,1)

Answer 3

you can use the transpose operation to do this:

Example:

In [2]: a = np.array([[1,2], [3,4], [5,6]])
In [5]: a.shape
Out[5]: (3, 2)

In [6]: a_trans = a.T    #or: np.transpose(a), a.transpose()
In [8]: a_trans.shape
Out[8]: (2, 3)
In [7]: a_trans
Out[7]: 
array([[1, 3, 5],
       [2, 4, 6]])

Note that the original array a will still remain unmodified. The transpose operation will just make a copy and transpose it.

---

If your input array is rather 1D, then you can promote the array to a column vector by introducing a new (singleton) axis as the second dimension. Below is an example:

# 1D array
In [13]: arr = np.arange(6)

# promotion to a column vector (i.e., a 2D array)
In [14]: arr = arr[..., None]    #or: arr = arr[:, np.newaxis]

In [15]: arr
Out[15]: 
array([[0],
       [1],
       [2],
       [3],
       [4],
       [5]])

In [12]: arr.shape
Out[12]: (6, 1)

---

For the 1D case, yet another option would be to use numpy.atleast_2d() followed by a transpose operation, as suggested by ankostis in the comments.

In [9]: np.atleast_2d(arr).T
Out[9]: 
array([[0],
       [1],
       [2],
       [3],
       [4],
       [5]])

Answer 4

This one is a really good question.

Some of the ways I have compiled to do this are:

>> import numpy as np
>> a = np.array([1, 2, 3], [2, 4, 5])
>> a
>> array([[1, 2],
       [2, 4],
       [3, 5]])

Another way to do it:

>> a.T
>> array([[1, 2],
       [2, 4],
       [3, 5]])
       

Another way to do this will be:

>> a.reshape(a.shape[1], a.shape[0])
>> array([[1, 2],
       [3, 2],
       [4, 5]])
       

I have used a 2-Dimensional array in all of these problems, the real problem arises when there is a 1-Dimensional row vector which you want to columnize elegantly.

Numpy's reshape has a functionality where you pass the one of the dimension (number of rows or number of columns) you want, numpy can figure out the other dimension by itself if you pass the other dimension as -1

>> a.reshape(-1, 1)
>> array([[1],
       [2],
       [3],
       [2],
       [4],
       [5]])
       
>> a = np.array([1, 2, 3])
>> a.reshape(-1, 1)
>> array([[1],
       [2],
       [3]])
       
>> a.reshape(2, -1)

>> ValueError: cannot reshape array of size 3 into shape (2,newaxis)

So, you can give your choice of 1-Dimension without worrying about the other dimension as long as (m * n) / your_choice is an integer.

If you want to know more about this -1 head over to: What does -1 mean in numpy reshape?

Note: All these operations return a new array and does not modify the original array.