2D Interpolation in Python

Use
scipy.interpolate.interp2d
to Create 2D Interpolation in Python 
Use
scipy.interpolate.Rbf
to Create Radial Basis Function for Interpolation in Python
This article shows how to do interpolation in Python and looks at different 2d implementation methods. We will discuss useful functions for bivariate interpolation such as scipy.interpolate.interp2d
, numpy.meshgrid
, and Radial Basis Function for smoothing/interpolation (RBF)
used in Python.
We will implement interpolation using the SciPy and Numpy libraries, making it easy.
Use scipy.interpolate.interp2d
to Create 2D Interpolation in Python
First of all, let’s understand interpolation, a technique of constructing data points between given data points. Let’s assume two points, such as 1 and 2.
In this example, we can interpolate and find points 1.22 and 1.44, and many more.
Interpolation is often used in Machine Learning to fill in missing data in a dataset, called imputation. Interpolation is frequently used to make a dataset’s points more uniform.
Let’s see working with examples of interpolation in Python using the scipy.interpolate
module.
The interp2d
is a straightforward generalization of the interp1d
function. This function takes the x and y coordinates of the available data points as separate onedimensional arrays and a twodimensional array of values for each pair of x and y coordinates.
The data points are assumed to be on a regular and uniform x and y coordinate grid. The general function form is below.
class scipy.interpolate.interp2d(x, y, z, kind='linear', copy=True, bounds_error=False, fill_value=None)
Where x
, y
, and z
are arrays, the kind could be {'linear', 'cubic', 'quintic'}
or may be left as optional. See also scipy.interpolate.interp2d
detailed documentation.
# import libraries
import numpy as np
from scipy import interpolate
import matplotlib.pyplot as plt
# x,y arrays
x = np.arange(5.01, 5.01, 0.25)
y = np.arange(5.01, 5.01, 0.25)
xx, yy = np.meshgrid(x, y) # see details below for 'np.meshgrid'
# approximate function which is z:= f(x,y)
z = np.sin(xx ** 2 + yy ** 2)
fun = interpolate.interp2d(
x, y, z, kind="linear"
) # kind could be {'linear', 'cubic', 'quintic'}
xnew = np.arange(5.01, 5.01, 1e2)
ynew = np.arange(5.01, 5.01, 1e2)
znew = fun(xnew, ynew)
plt.plot(x, z[0, :], "go", xnew, znew[0, :], "b")
plt.show()
Output:
Note that we have used numpy.meshgrid
to make the grid; you can make a rectangular grid out of two onedimensional arrays representing Cartesian or Matrix indexing. See numpy.meshgrid
documentation.
The general function form is below.
numpy.meshgrid(*xi, copy=True, sparse=False, indexing="xy")
The xi
represents onedimensional coordinate arrays x1
, x2
,…, xn
.
Use scipy.interpolate.Rbf
to Create Radial Basis Function for Interpolation in Python
This class of interpolation is used in the case of ndimensional scattered data; for this, we use scipy.interpolate.Rbf
.
import matplotlib.pyplot as plt
import numpy as np
from scipy.interpolate.rbf import Rbf # radial basis functions
# x y arrays
x = [1, 1, 2, 3, 4, 4, 2, 6, 7]
y = [0, 2, 5, 6, 2, 4, 1, 5, 2]
z = [1] * len(x)
# RBF Func
rbf_fun = Rbf(x, y, z, function="gaussian")
x_new = np.linspace(0, 8, 81)
y_new = np.linspace(0, 8, 82)
x_grid, y_grid = np.meshgrid(x_new, y_new)
z_new = rbf_fun(x_grid.ravel(), y_grid.ravel()).reshape(x_grid.shape)
plt.pcolor(x_new, y_new, z_new)
plt.plot(x, y, "o")
plt.xlabel("x")
plt.ylabel("y")
plt.title("RBF Gaussian interpolation")
Output:
This class of interpolating functions converts ND
scattered data to MD
with radial basis functions (RBF)
. Smoothing and interpolating scattered data in ndimensions can be accomplished using RBF interpolation.
Still, as there is a chance of extrapolation, like getting values outside the data range, this should be done carefully.
Maisam is a highly skilled and motivated Data Scientist. He has over 4 years of experience with Python programming language. He loves solving complex problems and sharing his results on the internet.
LinkedIn