- \n
- Introduction<\/a><\/li>\n
- Syntax<\/a><\/li>\n
- Examples<\/a><\/li>\n
- FAQ<\/a><\/li>\n<\/ul>\n
If you need something specific, you can click on any of the above links, and it will take you to the appropriate section of the tutorial.<\/p>\n
Having said that, if you’re new to Numpy, or need a quick refresher about mathematical dot products, you should probably read the whole tutorial.<\/p>\n
<\/a><\/p>\n
A Quick Introduction to Numpy Dot<\/h2>\n
First of all, let’s start with the basics.<\/p>\n
What does Numpy dot do?<\/p>\n
At a high level, Numpy dot computes the dot product of two Numpy arrays.<\/p>\n
If you’re a little new to Numpy though, or if you don’t completely understand dot products, that might not entirely make sense.<\/p>\n
So let’s quickly review some basics about Numpy and about dot products.<\/p>\n
Numpy dot operates on Numpy arrays<\/h4>\n
Let’s start with Numpy<\/a>.<\/p>\n
As you’re probably aware, Numpy is an add-on package for the Python<\/a> programming language.<\/p>\n
We mostly use Numpy for data manipulation and scientific computing, but we use Numpy on specific types of data in specific data structures.<\/p>\n
Numpy is a Package for Working with Numeric Data in Python<\/h5>\n
In particular, Numpy creates and operates on Numpy arrays.<\/p>\n
A Numpy array is a data structure that stores numerical data in a row and column structure.<\/p>\n
So for example, a 2-dimensional Numpy array looks something like this:<\/p>\n
![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2020\/12\/numpy-array-example_np-var.png\")
<\/p>\nNumpy arrays can come in a variety of shapes and sizes. For example, we can build 1-dimensional arrays, 2-dimensional arrays, and n-dimensional arrays.<\/p>\n
Additionally, we can create Numpy arrays where the Numbers have a variety of different properties. For example, we can create arrays that contain normally distributed numbers<\/a>, numbers drawn from a uniform distribution<\/a>, numbers that are all the same value<\/a>, just to name a few.<\/p>\n
So Numpy has a variety of functions for creating Numpy arrays with different types of properties.<\/p>\n
Numpy has Functions for Performing Calculations with Numpy Arrays<\/h4>\n
In addition to having functions for creating Numpy arrays, the Numpy package also has functions for operating on and computing with Numpy arrays.<\/p>\n
So Numpy has many functions for performing mathematical computations, like computing the sum of an array<\/a>, computing exponentials<\/a> of array values, and many more.<\/p>\n
Additionally, Numpy has functions for doing more advanced operations, like operations from linear algebra<\/a>.<\/p>\n
np.dot computes dot products in Numpy<\/h2>\n
So what does the Numpy dot function do?<\/p>\n
The simple explanation is that
np.dot<\/code> computes dot products. <\/p>\nTo paraphrase the entry on Wikipedia<\/a>, the dot product is an operation that takes two equal-length sequences of numbers and returns a single number.<\/p>\n
Having said that, the Numpy dot function works a little differently depending on the exact inputs. <\/p>\n
There are three broad cases that we’ll consider with
np.dot<\/code>:<\/p>\n- \n
- both inputs are 1D arrays<\/li>\n
- both are 2D arrays<\/li>\n
- one inputs is a scalar and one input is an array<\/li>\n<\/ul>\n
Let’s take a look at how Numpy dot operates for these different cases.<\/p>\n
If the input arrays are both 1-dimensional arrays, np.dot computes the vector dot product<\/h3>\n
Let’s say we have two Numpy arrays,
![\"\mathbf{a}\"](\"https:\/\/www.sharpsightlabs.com\/wp-content\/ql-cache\/quicklatex.com-640aa2103e4a2fd9643a5d518d0fcc8f_l3.png\" "\\"Rendered")
and ![\"\mathbf{b}\"](\"https:\/\/www.sharpsightlabs.com\/wp-content\/ql-cache\/quicklatex.com-8390e0680099f600fca6aaf21d4816c0_l3.png\" "\\"Rendered")
, and each array has 3 values.<\/p>\n![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2021\/01\/two-numpy-arrays_for-dot-product_example.png\")
<\/p>\nGiven two 1-dimensional arrays,
np.dot<\/code> will compute the dot product.<\/p>\nThe dot product can be computed as follows:<\/p>\n
![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2021\/01\/numpy-dot-product_simple-visual-example.png\")
<\/p>\nNotice what’s going on here. These arrays have the same length, and each array has 3 values. <\/p>\n
When we compute the dot product, we multiply the first value of
by the first value of . We multiply the second value of by the second value of . And we multiply the third value of by the third value of . Then, we take the resulting values, and sum them up.<\/p>\nThe output is a single scalar value … in this example,
![\"\mathbf{a} \cdot \mathbf{b} = 98\"](\"https:\/\/www.sharpsightlabs.com\/wp-content\/ql-cache\/quicklatex.com-6812b0a21e3a26cacccbe598041830c4_l3.png\" "\\"Rendered")
.<\/p>\nIn mathematical terms, we can generalize the example above. If we have two vectors
and , and each vector has ![\"n\"](\"https:\/\/www.sharpsightlabs.com\/wp-content\/ql-cache\/quicklatex.com-fbdaefcfe46d44fc6862c7ef0b98f40f_l3.png\" "\\"Rendered")
elements, then the dot product ![\"\mathbf{a} \cdot \mathbf{b}\"](\"https:\/\/www.sharpsightlabs.com\/wp-content\/ql-cache\/quicklatex.com-ac339e8ba732e4aa4c3d1f2350e987be_l3.png\" "\\"Rendered")
is given by the equation:<\/p>\n<\/a><\/p>\n
(1) <\/span> <\/span>
![\"\begin{equation*}](\"https:\/\/www.sharpsightlabs.com\/wp-content\/ql-cache\/quicklatex.com-1a8b9a83c1b5021fe5269643bfa4e41e_l3.png\" "\\"Rendered")
<\/p>\nEssentially, when we take the dot product of two Numpy arrays, we’re computing the sum<\/em> of the pairwise products<\/em> of the two arrays. <\/p>\n
If one of the inputs is a scalar, np.dot performs scalar multiplication<\/h3>\n
The second case is when one input is a scalar value
![\"r\"](\"https:\/\/www.sharpsightlabs.com\/wp-content\/ql-cache\/quicklatex.com-ed18b841732d371cf14ab9562762b984_l3.png\" "\\"Rendered")
, and one input is a Numpy array, which here we’ll call .<\/p>\n![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2021\/01\/numpy-dot_one-scalar-and-one-array_example.png\")
<\/p>\nIf we use Numpy dot on these inputs with the code
np.dot(r,b)<\/code> Numpy will perform scalar multiplication<\/em> on the array:<\/p>\n![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2021\/01\/numpy-dot_scalar-multiplication_visual-example.png\")
<\/p>\nSo when we use Numpy dot with one scalar and one Numpy array, it multiples every value of the array by the scalar and outputs a new Numpy array.<\/p>\n
If both inputs are 2D arrays, np.dot performs matrix multiplication<\/h3>\n
The final case that we’ll cover is when both of the input arrays are 2-dimensional arrays.<\/p>\n
In this case, with two 2D arrays, the
np.dot<\/code> function will perform matrix multiplication<\/a>.<\/p>\nA full explanation of matrix multiplication is beyond the scope of this tutorial, but let’s look at a quick example.<\/p>\n
Let’s say that you have two 2D arrays,
![\"\mathbf{A}\"](\"https:\/\/www.sharpsightlabs.com\/wp-content\/ql-cache\/quicklatex.com-7f089ff6951ce4d2378ccae109ba6158_l3.png\" "\\"Rendered")
and ![\"\mathbf{B}\"](\"https:\/\/www.sharpsightlabs.com\/wp-content\/ql-cache\/quicklatex.com-e8a7d2a890e9b6b133f81ad08a4ddd52_l3.png\" "\\"Rendered")
.<\/p>\n![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2021\/01\/numpy-dot_two-2D-arrays_example.png\")
<\/p>\nNext, let’s multiply those arrays together using matrix multiplication.<\/p>\n
During matrix multiplication, we multiply the values of the rows of
with the values of the columns of and sum them up in the following way:<\/p>\n![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2021\/01\/numpy-dot_matrix-multiplication_two-2D-arrays_example.png\")
<\/p>\nAnd here’s the final computed output:<\/p>\n
![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2021\/01\/numpy-dot_matrix-multiplication_two-2D-arrays_example-output.png\")
<\/p>\nNotice that the output array,
![\"\mathbf{C} = \mathbf{AB}\"](\"https:\/\/www.sharpsightlabs.com\/wp-content\/ql-cache\/quicklatex.com-c071b3e49054eedea76d19246d29008a_l3.png\" "\\"Rendered")
, has the same number of rows as and the same number of columns as .<\/p>\nAdditionally, each value in the output array
![\"\mathbf{C}\"](\"https:\/\/www.sharpsightlabs.com\/wp-content\/ql-cache\/quicklatex.com-c934ada8e97699a8edf4ec68af9f9229_l3.png\" "\\"Rendered")
is calculated by summing the product of the i<\/em>th row of and the j<\/em>th row of .<\/p>\nMore generally, to compute the output array
, each value of the output array ![\"C_{i,j}\"](\"https:\/\/www.sharpsightlabs.com\/wp-content\/ql-cache\/quicklatex.com-bb8bf52975ec60a62a632044b3fba778_l3.png\" "\\"Rendered")
is defined as:<\/p>\n<\/a><\/p>\n
(2) <\/span> <\/span>
![\"\begin{equation*}](\"https:\/\/www.sharpsightlabs.com\/wp-content\/ql-cache\/quicklatex.com-4138e6245b86c9157e474035e354af77_l3.png\" "\\"Rendered")
<\/p>\nIf you’re not familiar with linear algebra generally, and matrix algebra specifically, I realize that these equations can be a little confusing. Maybe even a little intimidating.<\/p>\n
That said, if you want to learn more about these operations, I recommend that you read the book Linear Algebra and its Applications<\/a>, by David Lay and colleagues. It’s a very approachable book about linear algebra that will help you understand some of the operations we’re performing with Numpy dot.<\/p>\n
Ok. So now that we’ve looked at what Numpy dot does, let’s take a closer look at the syntax.<\/p>\n
<\/a><\/p>\n
The Syntax of Numpy Dot<\/h2>\n
Here, I’ll explain the syntax of the Numpy dot function.<\/p>\n
A quick note<\/h4>\n
One thing before we look at the syntax. <\/p>\n
In order to use Numpy functions, you need to import Numpy first. You can do that with the following code:<\/p>\n
\r\nimport numpy as np\r\n<\/pre>\n
This is important, because how you import Numpy will affect the syntax.<\/p>\n
It’s the common convention among Python data scientists to import Numpy with the alias ‘
np<\/code>‘, and we’ll be sticking with that convention here.<\/p>\nnp.dot syntax<\/h3>\n
The syntax of
np.dot<\/code> is really very simple.<\/p>\nAssuming that you’ve imported Numpy with the alias
np<\/code>, you call the function asnp.dot()<\/code>.<\/p>\n![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2021\/01\/numpy-dot_syntax-explanation.png\")
<\/p>\nThen, inside the parenthesis, there are a few parameters that allow you to provide inputs to the function.<\/p>\n
Let’s take a look at those inputs.<\/p>\n
The parameters of np.dot<\/h3>\n
There are 2 core parameters for the
np.dot()<\/code> function.<\/p>\n- \n
a<\/code><\/li>\nb<\/code><\/li>\n<\/ul>\nLet’s quickly take a look at those, one by one.<\/p>\n
a<\/code> (required)<\/h6>\nThe
a<\/code> parameter allows you to specify the first input value or array to the function.<\/p>\nTechnically, the argument to this parameter can be a scalar value, or any “array-like” object. <\/p>\n
Because it allows array-like objects, this can be a proper Numpy array, or it can be a Python list, a tuple, etc. A scalar value like an
int<\/code> orfloat<\/code> will also work.<\/p>\nKeep in mind that you must provide an argument to this parameter.<\/p>\n
b<\/code> (required)<\/h6>\nThe
b<\/code> parameter allows you to specify the second input value or array to the function.<\/p>\nSimilar to the
a<\/code> parameter, the argument tob<\/code> can be a scalar value, or any “array-like” object. So acceptable arguments to this parameter include Numpy arrays, Python lists, and tuples. Scalar values like anint<\/code> orfloat<\/code> are acceptable as well.<\/p>\nKeep in mind that you must provide an argument to this parameter.<\/p>\n
out<\/code> (optional)<\/h6>\nNote that
np.dot()<\/code> also has anout<\/code> parameter. This is somewhat rarely used, so we’re not going to cover it here. For more information about this parameter, review the official documentation.<\/p>\nThe output of np.dot<\/h3>\n
The output of
np.dot()<\/code> depends on the inputs.<\/p>\nThere are a few cases:<\/p>\n
- \n
- If both inputs are scalars,
np.dot()<\/code> will multiply the scalars together and output a scalar.<\/li>\n- If one input is a scalar and one is an array,
np.dot()<\/code> will multiply every value of the array by the scalar (i.e., scalar multiplication).<\/li>\n- If both inputs are 1-dimensional arrays,
np.dot()<\/code> will compute the dot product of the inputs<\/li>\n- If both inputs are 2-dimensional arrays, then
np.dot()<\/code> will perform matrix multiplication.<\/li>\n<\/ul>\nSo as you can see, the output really depends on how you use the function.<\/p>\n
With that in mind, let’s take a look at some examples so you can see how it works, and see the different types of outputs that
np.dot()<\/code> produces given certain types of inputs.<\/p>\n<\/a><\/p>\n
Examples: How to Compute Dot Products in Numpy<\/h2>\n
Ok. Let’s work through some step-by-step examples.<\/p>\n
If you need something specific, you can click on any of the following links, and it will take you to the approprate example.<\/p>\n
Examples:<\/strong><\/p>\n
- \n
- Multiply two numbers<\/a><\/li>\n
- Multiply a Number and an Array<\/a><\/li>\n
- Compute the Dot Product of Two 1D Arrays<\/a><\/li>\n
- Perform Matrix Multiplication on Two 2D Arrays<\/a><\/li>\n<\/ul>\n
Run this code first<\/h4>\n
Before you run any of the examples, you’ll need to import Numpy first.<\/p>\n
You can do that with the following code:<\/p>\n
\r\nimport numpy as np\r\n<\/pre>\n
Once you’ve done that, you should be ready to go.<\/p>\n
<\/a><\/p>\n
EXAMPLE 1: Multiply two numbers<\/h3>\n
Ok. Let’s start with a simple example. <\/p>\n
Here, we’re going to use two numbers (i.e., scalar values) as the inputs to
np.dot()<\/code>.<\/p>\n\r\nnp.dot(2,3)\r\n<\/pre>\n
OUT:<\/p>\n
\r\n6\r\n<\/pre>\n
Explanation<\/h6>\n
This is maybe a little unexpected, but very simple.<\/p>\n
Here, we called
np.dot()<\/code> with two scalar values, 2 and 3.<\/p>\nWhen we call
np.dot()<\/code> with two scalars, it simply multiplies them together.<\/p>\nObviously
2 * 3 = 6<\/code>.<\/p>\n<\/a><\/p>\n
EXAMPLE 2: Multiply a Number and an Array<\/h3>\n
Next, let’s provide an array and scalar as inputs.<\/p>\n
Here, we’ll actually provide a scalar (an integer) and a Python list. Instead of a Python list, we could also provide a Numpy array, but I’ve used a Python list instead because it makes the operation a little easier to understand here.<\/p>\n
Let’s take a look.<\/p>\n
\r\nnp.dot(2,[5,6])\r\n<\/pre>\n
OUT:<\/p>\n
\r\narray([10, 12])\r\n<\/pre>\n
Explanation<\/h6>\n
Again, this is very simple.<\/p>\n
The first argument to the function is the scalar value 2.<\/p>\n
The second argument to the function is the Python list
[5,6]<\/code>.<\/p>\nWhen we provide a scalar as one input and a list (or Numpy array) as the other input,
np.dot()<\/code> simply multiplies the values of the array by the scalar.<\/p>\nMathematically, we’d consider this to be scalar multiplication of a vector or matrix.<\/p>\n
<\/a><\/p>\n
EXAMPLE 3: Compute the Dot Product of Two 1D Arrays<\/h3>\n
Next, let’s input two 1-dimensional lists.<\/p>\n
Here, we’ll use two Python lists, but we could also use 1D Numpy arrays. I’m using Python lists because it makes the operation a little easier to understand at a glance.<\/p>\n
Let’s take a look.<\/p>\n
\r\nnp.dot([3,4,5],[7,8,9])\r\n<\/pre>\n
OUT:<\/p>\n
\r\n98\r\n<\/pre>\n
Explanation<\/h6>\n
What’s going on here?<\/p>\n
Here, the
np.dot()<\/code> is computing the dot product of the two inputs.<\/p>\nThese inputs are 1-dimensional Python lists. And as I said earlier, we could also use 1D Numpy arrays.<\/p>\n
Mathematically, 1D lists and 1D Numpy arrays are like vectors<\/a><\/em>.<\/p>\n
When we’re working with vectors and take the dot product, the dot product is computed by equation 1<\/a> that we saw earlier.<\/p>\n
<\/span> <\/span>
![\"\[](\"https:\/\/www.sharpsightlabs.com\/wp-content\/ql-cache\/quicklatex.com-80be6e68fd97b6d6d007cd8544275d5e_l3.png\" "\\"Rendered")
<\/p>\nSo when Numpy dot has two 1D lists or arrays as inputs …<\/p>\n
<\/p>\n… it takes the product of the pairwise elements, and then adds them together:<\/p>\n
<\/p>\nAnd the output is a scalar value. In this case, the result is 98.<\/p>\n
<\/a><\/p>\n
EXAMPLE 4: Perform Matrix Multiplication on Two 2D Arrays<\/h3>\n
Finally, let’s look at what happens when we use Numpy dot on two 2-dimensional arrays.<\/p>\n
Create Arrays<\/h6>\n
First, let’s just create two 2-dimenstional Numpy arrays.<\/p>\n
To do this, we’ll use the
np.arange()<\/code> function to create a sequence of numbers<\/a>, and then use the Numpy reshape method to reshape the numbers into a 2D shape<\/a>.<\/p>\n\r\nA_array_2d = np.arange(start = 3, stop = 9).reshape((2,3))\r\nB_array_2d = np.arange(start = 10, stop = 16).reshape((3,2))\r\n<\/pre>\n
And let’s print them out, just so you can see the contents.<\/p>\n
\r\nprint(A_array_2d)\r\n<\/pre>\n
OUT:<\/p>\n
\r\n[[3 4 5]\r\n [6 7 8]]\r\n<\/pre>\n
\r\nprint(B_array_2d)\r\n<\/pre>\n
OUT:<\/p>\n
\r\n[[10 11]\r\n [12 13]\r\n [14 15]]\r\n<\/pre>\n
Notice that both of these Numpy arrays are 2-dimensional. Having said that, the number of rows in
A_array_2d<\/code> is the same as the number of columns inB_array_2d<\/code>.<\/p>\nUse np.dot<\/h6>\n
Ok. Now let’s use the Numpy dot function on these two arrays.<\/p>\n
\r\nnp.dot(A_array_2d, B_array_2d)\r\n<\/pre>\n
OUT:<\/p>\n
\r\narray([[148, 160],\r\n [256, 277]])\r\n<\/pre>\n
Explanation<\/h6>\n
So what happened here?<\/p>\n
In this case, we used two 2-dimensional Numpy arrays as the inputs.<\/p>\n
<\/p>\nWhen we use 2D arrays as inputs,
np.dot()<\/code> computes the matrix product<\/em> of the arrays.<\/p>\nWhen it does this, it
np.dot()<\/code> calculates the values of the output array according to equation 2 that we saw earlier<\/a>.<\/p>\n<\/span> <\/span>
![\"\[](\"https:\/\/www.sharpsightlabs.com\/wp-content\/ql-cache\/quicklatex.com-3bdc81505b7fe77720a567cc89ba3dd3_l3.png\" "\\"Rendered")
<\/p>\nSo under the hood, this is what Numpy is doing when we run the code
np.dot(A_array_2d, B_array_2d)<\/code> :<\/p>\n<\/p>\nLook carefully. In the above image, you can see that the computation multiplies the values of the rows of A by the values of the columns of B, sums them up, and puts them into the final output array, with the following values:<\/p>\n
<\/p>\nThis operation is known as the matrix product.<\/p>\n
So again: when we use Numpy dot on two 2-dimensional arrays,
np.dot()<\/code> computes the matrix product.<\/p>\nI understand that this might be slightly confusing if you don’t have a lot of experience with linear algebra. If that’s the case, I recommend that you do some reading about linear algebra generally, and matrix multiplication in particular.<\/p>\n
<\/a><\/p>\n
Frequently asked questions about Numpy Dot<\/h2>\n
Now that we’ve looked at some examples, let’s look at a few common questions about the
np.dot()<\/code> function.<\/p>\nFrequently asked questions:<\/strong><\/p>\n
- \n
- What’s the difference between
np.dot()<\/code> andnp.matmul()<\/code> ?<\/a><\/li>\n- What’s the difference between
np.dot()<\/code> andndarray.dot()<\/code> ?<\/a><\/li>\n<\/ul>\n<\/a><\/p>\n
Question 1: What’s the difference between
np.dot()<\/code> andnp.matmul()<\/code> ?<\/h3>\nNumpy dot and Numpy matmul are similar, but they behave differently for some types of inputs.<\/p>\n
The two big differences are for:<\/p>\n
- \n
- multiplication by scalars<\/li>\n
- multiplication of high-dimensional Numpy arrays<\/li>\n<\/ul>\n
Let’s look at these one at a time.<\/p>\n
Multiplication by scalars<\/h6>\n
The first difference between
np.dot()<\/code> andnp.matmul()<\/code> is thatnp.dot()<\/code> allows you to multiply by scalar values, butnp.matmul()<\/code> does not.<\/p>\n
- What’s the difference between
- Multiply a Number and an Array<\/a><\/li>\n
- If one input is a scalar and one is an array,
- Syntax<\/a><\/li>\n