In this week we'll see the final part of all the functions that we may need to use numpy in our machine learning project.
Let's dive in!
table of contents:
- Viewing the operation performance
- Reshaping and transposing
- Matrix multiplication
- Comparison operators
- Sorting arrays
- Finding the maximum value of an array
- Final thoughts
In python, using numpy, as well as other languages, we'll have a lot of ways to do the same thing; In python, we have the sum function and with numpy we have to np.sum function too.
When is a function better than the other?
Num is the official python function to sum python lists, while the np.sum function is the official function to sum numpy arrays, which are the same thing conceptually, but not when the machine has to perform the calculation.
The best way to act is to use python function for python data types (in this case lists) and numpy functions for numpy data types (numpy arrays and types).
But an even more important difference besides the performance of these two functions. With some special numpy functions (characterized by the % at the beginning) we can display the time that the machine took to perform the operations, in this case, we'll use %timeit.
We'll first create a big array:
As we already stated, one of the most important things to be sure in our carrier in machine learning is that data fit other data, let's see it with an example.
Let's begin with creating two different arrays with different shapes:
When operating on two arrays, NumPy compares their shapes element-wise. It starts with the trailing (i.e. rightmost) dimensions and works its way left. Two dimensions are compatible when
- they are equal, or
- one of them is 1
That means that we have to reshape our array, and we can do it with the numpy reshape function:
Note that the reshape function follows precises rules and that this is just an example, an array cannot be always reshaped into something different.
Now that we have seen the reshape function let's see the transpose one.
Both reshape and transpose are very useful function that will come in very handy when we'll have to do multiplicate two - or more - matrices
Multiplying a matrix by a single number or a one-dimensional array is fairly easy, but multiplying a matrix by another matrix is something that will be a bit tough to understand but very important.
There are two ways to multiplicate array for each other:
An element-wise multiplication is very easy and can be done only between arrays of the same size:
and we can do it with the numpy function:
Note: in the following examples there is an error in the matrix: it has the 5 instead of 4 and viceversa.
The other one is specific for matrices and if you don't understand it on the first try, don't worry, is simple if you understand what's going on.
As you can see, we took the first array with the matrix with '1', '2', and '3' and multiplied it for 'A', 'B' and 'C'. This is commonly called the waterfall method. You can understand why viewing the animation here.
As a general rule, to multiply two matrices together they need to be aligned. Let's see what happens if we try to use the dot product on the matrices that have multiplied element-wise, using the dot function:
As you can see they are not aligned. Two matrices are aligned when the the row o of the first is the same as the column of the other, or:
m x n * n x p. This way we know that the result will be a matrix that is m x p:
m x n * n x p = m x p that in our case could be: 3 x 2 * 2 * 3 = 3 * 3
that means that two matrices can be multiplied. In our case we have to transpose the axis:
In our case we got as result a 2 x 2 matrix, as we already saw:
2 x 3 * 3 x 2 = 2 x 2
Exactly as we expected. If we would have transposed the first matrix the result would have been a 3 x 3 matrix.
To see the dot product from a mathematical point of view you can read here.
Between arrays and matrices we can even do comparisons. The result will be another boolean array. Let's see an example:
Numpy offers various functions for finding an element and for sorting an array. The most common way is sort, that sort when applied on a matrix every row of it.
To find the minimum value of an array numpy offers the argmin function, that returns the index of the lowest value:
If to find the minimum we use argmin, to find the maximum we find argmax:
Both the function let us enter the axis of the array so that we can find the maximum or the minimum not of all the array but of all the columns or rows:
This and last week we saw the numpy library to manipulate arrays and matrices, the datasets that we'll have in machine learning. Next week we'll see matplotlib to visualize our data, for then focusing on something more practical. If you have any doubt feel free to leave a comment.