# Difference in output for dot product using transpose of matrix - Vectors - Screen 6

I have a doubt regarding the code output for the below screen:

My code is shown below

``````vector_one = np.asarray([
,
,

], dtype=np.float32)

vector_two = np.asarray([
,
,

], dtype=np.float32)

dot_product = np.dot(vector_one[:,0], vector_two)
dot_product2 = np.dot(vector_one.T, vector_two)
print(dot_product)
print(dot_product2)

print(dot_product.shape)
print(dot_product2.shape)
``````

While taking the dot product we need to convert one of the column vectors to row vector. In the solution provided this was done using vector_one[:,0]
The result is [4.]
I implemented the solution using the transpose attribute vector_one.T
The result isn [[4.]]

Both the above outputs are numpy arrays but the shape for 1st one is (1,) whereas for the 2nd output is (1,1). What is the difference between the two outputs?

`vector_one[:,0]` gives you a vector so the result of your dot product is a vector too
`T` (matrix transpose) just output the transposed matrix so your dot product is a 1 x 1 matrix

As said in the course:

• matrix vector multiplication = dot product between a matrix and a column vector
• matrix multiplication : dot product between each row of the first matrix and each column of the 2nd matrix. When you use transpose you make matrix multiplication, so your output is a matrix

Can you please explain one more thing
The column vector has shape (3,1)
Going by that row vector should have shape (1,3) which is the case when I use transpose
What does the shape (3, ) mean when we do vector_one[:,0] and given the different dimensions how come both work in the above code?

I agree this is confusing. And now I am a little bit in trouble too!

If you want to make the dot product with the 2d array after using `T`, you will need to select the first row so you will have a row vector:

``````transposed = vector_one.T
dot_product = np.dot(transposed[0,:], vector_two)
``````

Let’s print the shapes so maybe it will become more intuitive:

``````print(vector_one[:,0].shape)
print(vector_two.shape)
print(vector_one.T.shape)
print(vector_one.T[0,:].shape)
``````

Output:

``````(3,)
(3, 1)
(1, 3)
(3,)
``````

First case: dot product with (m,) and (m,n) => returns a 1d array of shape (n,)
Second case: dot product with (n,m) and (m,n) => returns a 2d array of shape (n,n)

What numpy is doing in the first case :
[3x1 + 0x2 + 1x1] = 
What numpy is doing in the second case :
[[3x1 + 0x2 + 1x1]] = []

Think we need other fellows for better explanations and rectify if I have made incorrect statements.

Actually you don’t need to do `transposed[0,:]` for dot product. You can just do `np.dot(**transposed**, vector_two)` and still get the same result, only difference being the dimension of the output.
I think the important takeaway from this would be:

1. dot product of 1D array (m,) with 2D (m,n) array will return a 1D array
2. dot product of 2D array (n,m) with 2D (m,n) array will return a 2D array

Need to understand the 1st case a bit better since it looks counterintuitive from matrix multiplication perspective.

I know, but I just wanted to highlight the fact doing `transposed[0,:]` you will find the same dimension output than in the course.

Regarding the difference between (3,) and (3,1): think a list vs list of lists.

1 Like