Numpy Meshgrid, Explained
This article is originally published at https://www.sharpsightlabs.com
This tutorial will show you how to use Numpy meshgrid.
It will explain what the meshgrid function does, explain the syntax, and show you clear examples to help develop your intuition for how this technique works.
If you need something specific, you can click on any of the following links.
Table of Contents:
Having said that, Numpy meshgrid is fairly complicated to understand, and I recommend that you read this tutorial from start to finish.
A quick introduction to Numpy Meshgrid
Numpy meshgrid is a tool for numeric data manipulation in Python.
We use Numpy meshgrid to create a rectangular grid of x and y values.
More specifically, meshgrid creates coordinate values that enable us to construct a rectangular grid of values.
It does this in a somewhat roundabout way.
As inputs to the function, we provide 1-dimensional arrays with numeric values. These numeric values will be the coordinates of the new “meshgrid.”
The output of np.meshgrid is a set of Numpy arrays that contain the coordinates of this new grid space.
It’s a complicated way to create coordinates at every point in a grid-like space; a “meshgrid,” if you will.
This this function often confuses beginners, and I think that the best way to understand it is with examples. I’m going to show you some examples below, but first, let’s look at the syntax.
The Syntax of Numpy Meshgrid
Now that you’ve learned what Numpy meshgrid does at a high level, let’s get into the details and look at the syntax.
A quick note
Before I move on, one quick note:
Remember that when we import Numpy, we almost always import it with the alias,
np, which allows us to call Numpy functions with the suffix
import numpy as np
That’s the common convention among Python data scientists, and going forward, I’ll assume that you’ve imported Numpy this way.
The syntax is somewhat simple.
You call the function as
Inside the parenthesis, the first arguments should be 1D Numpy arrays (or array like objects) that contain the values you want to use as grid coordinates.
There are also some optional parameters like the sparse parameter that we’ll discuss in a moment.
The arguments and parameters of np.meshgrid
Let’s look at the inputs and optional parameters of np.meshgrid.
x1, x2, ... xn
x1, x2, ... xn (required)
These are the input arrays to the function.
These should be 1-dimensional Numpy arrays with numeric values, although they can also be array-like objects, such as Python lists.
Most commonly, we use two input arrays. This will cause Numpy meshgrid to create a 2D grid space.
However, it’s technically possible to have only one input array, for a 1D “grid.”
It’s also possible to provide three or more input arrays, which will create the values for a higher-dimensional grid space.
sparse parameter enables you to specify if you want the function to strictly create values for the axes (like axis tick mark values), or if you want it to create full grids of coordinate values.
If you set
sparse = True, it will only create values for the axes of the new space.
If you set
sparse = False, it will create coordinates for every new point in the created grid space. The setting
sparse = False is the default.
You should look at example 1 to see what happens when we set
sparse = True. I think that example will clarify what this does.
indexing parameter controls how the outputs are indexed.
indexing = 'xy'creates output with Cartesian indexing
indexing = 'ij'creates output with matrix indexing
'xy' is the default.
Examples of How to use Numpy Meshgrid
Now that we’ve looked at the syntax, let’s look at some example of Numpy meshgrid.
- Numpy meshgrid with
sparse = True
- Numpy meshgrid with two inputs and two 2D output arrays
- A “real world” machine learning example that shows how we use Numpy meshgrid
Run this code first
One quick note before we run the examples.
All of these examples assume that you’ve imported Numpy.
The common convention is to import Numpy with the alias “
You can do that like this:
import numpy as np
Once you run that code, you’ll be read to run the examples.
EXAMPLE 1: Numpy meshgrid with “sparse = True”
Here, instead of starting with the simplest example that removes any optional parameters, we’re going to start with an example that actually uses one of the optional parameters.
Specifically, we’re going to use the
sparse parameter, and set
sparse = True.
Let’s run it and look at the output, and then I’ll explain why this is useful.
np.meshgrid([1,2,3], [5,6,7], sparse = True)
[array([[1, 2, 3]]), array([, , ])]
Take a look at the inputs and then look at the outputs.
The inputs are two 1-dimensional Python lists:
[5,6,7]. Here, I used lists instead of Numpy arrays, to make the code easier to read, but we could have also used 1D Numpy arrays, just the same.
So the inputs are 1D Python lists.
But the outputs are 2D Numpy arrays.
And most importantly look at how they are structured.
The first array,
[[1, 2, 3]], has been kept horizontal.
But the second array is structured vertically:
You need to think of these outputs like x-axis values and y-axis values.
Numpy meshgrid is creating outputs that we could use for a Euclidean, x/y grid.
So we’re providing the input values, and it’s producing outputs that can act like x and y axis values.
Importantly, when we set
sparse = True, np.meshgrid only produces outputs that act like the axis-values of a coordinate system.
As you’ll see in the upcoming examples, if set
sparse = False, then np.meshgrid will produce values for all points in the new grid coordinate system.
(Note that everything I said above applies to the 2D case, and will be more complicated with for n-dimensional inputs.)
EXAMPLE 2: Numpy meshgrid with two inputs and two 2D output arrays
Next, we’ll look at a very simple example without any additional parameters.
So here, we’ll use Numpy meshgrid with two Python lists as inputs.
And we’ll remove the
sparse parameter that we saw in example 1.
Let’s take a look:
And here is the output:
[array([[1, 2, 3], [1, 2, 3], [1, 2, 3]]), array([[5, 5, 5], [6, 6, 6], [7, 7, 7]])]
You’ll notice that the code is fairly simple, but the output is somewhat more complex than the output we saw in example 1.
In example 1, we set
sparse = True, but here we’ve removed the
sparse parameter, so it’s being set to the default of
sparse = False.
Here, I’ve color-coded the outputs, just to help you see how they are structured.
Notice the relationship between the input and the output.
In this example, there are two 2-dimensional output arrays.
The first output array contains the values from the first input: 1,2,3. But these values have been repeated downward.
The second output array contains the values from the second input: 5,6,7. But these values have been repeated across.
Meshgrid is creating coordinates for a grid of values
You might be asking, what exactly are these two output arrays for?
Numpy meshgrid is providing us with coordinates.
As I suggested previously, meshgrid is creating coordinates that would allow us to create a Euclidean, x and y space. (At least, that’s the case in this example. It’s giving us coordinates for a 2D space. If we used higher-dimensional inputs, it might give us coordinates for a higher-dimensional space. But that’s a lot more complicated, so forget that right now.)
What does this look like?
Think of a set of coordinates in a grid-like Euclidean space, defined by the values in the input arrays:
That’s it guys.
That’s what meshgrid does.
It’s a complicated, ass-backwards, hard-to-understand method of creating coordinates for a grid system.
EXAMPLE 3: A “real world” machine learning example that shows how we use Numpy meshgrid
Let’s finally do a “real world” example where we actually use Numpy meshgrid for something useful.
Here, we’re going to use Numpy meshgrid to visualize the decision boundary of a machine learning model.
I’ll admit: this is a complicated example, and there’s a lot going on here. If you’re confused by this, you should consider enrolling in our Numpy course or our Python machine learning course.
Ok, we’ll start by importing our packages.
# IMPORT PACKAGES import numpy as np import plotly.graph_objects as go import seaborn as sns from sklearn.datasets import make_moons from sklearn.model_selection import train_test_split from sklearn.neighbors import KNeighborsClassifier
Next, we need to create a dataset and split it.
Here, we’re going to use scikit learn make_moons to create moon-shaped data.
# LOAD DATA X, y = make_moons(n_samples = 200 ,noise = .1 ,random_state = 3 ) X.shape y.shape
Here, we’ll visualize it with the Seaborn scatterplot function:
# PLOT DATA plt.style.use('fivethirtyeight') sns.scatterplot(x = X[:,0], y = X[:,1], hue = y)
Now we’ll split the data with the Sklearn train_test_split function.
#------------------------- # CREATE TRAIN & TEST DATA #------------------------- (X_train, X_test, y_train, y_test) = train_test_split(X ,y ,test_size = .2 )
Ok. Here’s the part where we use meshgrid.
We’re going to create a grid of x/y coordinates with Numpy meshgrid.
To to this, you’ll note that I’m setting a
grid_unit_size, which is the size of the steps in the grid.
I’m also setting the boundaries of the grid space with
Notice also that I’m using the Numpy arange function to create the x-range and y-range for the data. These serve as inputs to meshgrid.
# CREATE MESHGRID ON WHICH WE WILL RUN OUR MODEL grid_unit_size = .02 margin = 0.25 x_min = X[:, 0].min() - margin x_max = X[:, 0].max() + margin y_min = X[:, 1].min() - margin y_max = X[:, 1].max() + margin x_range = np.arange(start = x_min, stop = x_max, step = grid_unit_size ) y_range = np.arange(start = y_min, stop = y_max, step = grid_unit_size ) x_gridvalues, y_gridvalues = np.meshgrid(x_range, y_range)
Next, we’ll create a KNN classifier model.
# INITIALIZE CLASSIFIER AND FIT MODEL knn_classifier = KNeighborsClassifier(15, weights='uniform') knn_classifier.fit(X, y)
And now that we have our model, we’ll use it to compute values on our grid.
# COMPUTE PROBABILITIES ON GRID gridvalues_combined_tidy = np.vstack([x_gridvalues.flatten(), y_gridvalues.flatten()]).T knn_class_probabilities = knn_classifier.predict_proba(gridvalues_combined_tidy) probability_postive_class = knn_class_probabilities[:,1]
After doing this, we have the class probabilities for the positive class.
Finally, we can plot them using Plotly:
# PLOT THE PROBABILITIES ON THE MESHGRID fig = go.Figure(data=[ go.Contour( x = x_range ,y = y_range ,z = probability_postive_class.reshape(x_gridvalues.shape) ,colorscale = 'RdBu' #,alpha = .3 ) ]) fig.show()
I’ll admit: there’s a lot going on here. I’m sure that it’s a bit hard to understand if you’re a beginner.
But really, you just need to know the little functions and tools that we use to do all of this.
Numpy meshgrid is one, but to really understand this, you need to know a fair amount about Numpy, scikit learn, and data visualization in Python (Seaborn and/or Plotly).
Frequently asked questions about Numpy Meshgrid
Now that we’ve looked at how Numpy meshgrid works, and looked at some examples, let’s look at some frequently asked questions about the function.
Frequently asked questions:
Question 1: Why is Numpy Meshgrid so hard to understand?
I’m convinced that the guys who designed Python data scientists are sadists.
Half the tools for Python data science are much harder than they need to be.
(If you don’t believe me, try using R instead.)
Question 2: What does Numpy meshgrid do?
It creates arrays with numeric values, and the values function like coordinates for a grid-like space.
I recommend reviewing example 2 to really see what’s going on.
Question 3: Why are you so great at explaining complicated Python tools, Josh
Because I’m a gentleman and a scholar.
Leave your other questions in the comments below
Have other questions about meshgrid?
Did I forget something?
Leave your extra questions in the comments section at the bottom of the page.
For more Numpy tutorials, sign up for our email list
This tutorial should have helped you understand how to use Numpy meshgrid, but if you want to be great at data science and ML in Python, then there’s a lot more to learn.
If you’re ready to master data science and machine learning in Python, then sign up for our FREE email list.
When you sign up, you’ll get free tutorials on:
- Base Python
- Scikit learn
- Machine learning
- Deep learning
- … and more.
Again, to sign up for this free email list, just enter your best email address here:
Please visit source website for post related comments.