谁能给我解释一下Numpy中网格函数的目的是什么?我知道它创建了某种用于绘图的坐标网格，但我真的看不到它的直接好处。
我正在学习Sebastian Raschka的“Python机器学习”，他正在用它来绘制决策边界。请看这里的输入11。
我也从官方文档中尝试了这段代码，但是，同样，输出对我来说没有意义。
x = np.arange(-5, 5, 1)
y = np.arange(-5, 5, 1)
xx, yy = np.meshgrid(x, y, sparse=True)
z = np.sin(xx**2 + yy**2) / (xx**2 + yy**2)
h = plt.contourf(x,y,z)
如果可能的话，请给我展示一些真实的例子。
当前回答
幕后故事:
import numpy as np
def meshgrid(x , y):
XX = []
YY = []
for colm in range(len(y)):
XX.append([])
YY.append([])
for row in range(len(x)):
XX[colm].append(x[row])
YY[colm].append(y[colm])
return np.asarray(XX), np.asarray(YY)
让我们以@Sarsaparilla的答案为例:
y = [7, 6, 5]
x = [1, 2, 3, 4]
xx, yy = meshgrid(x , y)
输出:
>>> xx
array([[1, 2, 3, 4],
[1, 2, 3, 4],
[1, 2, 3, 4]])
>>> yy
array([[7, 7, 7, 7],
[6, 6, 6, 6],
[5, 5, 5, 5]])
其他回答
实际上np的目的。在文档中已经提到了Meshgrid:
np.meshgrid 从坐标向量返回坐标矩阵。 在给定一维坐标数组x1, x2，…, xn。
它的主要目的是创建一个坐标矩阵。
你可能会问自己:
为什么我们需要创建坐标矩阵?
你需要使用Python/NumPy坐标矩阵的原因是，坐标和值之间没有直接关系，除非你的坐标从0开始并且是纯正整数。然后你可以使用数组的下标作为下标。 然而，当情况并非如此时，您需要以某种方式将坐标存储在数据旁边。这就是网格的用武之地。
假设你的数据是:
1 2 1
2 5 2
1 2 1
但是，每个值代表3 x 2公里的面积(水平x垂直)。假设你的原点是左上角，你想用数组来表示你可以使用的距离:
import numpy as np
h, v = np.meshgrid(np.arange(3)*3, np.arange(3)*2)
其中v为:
array([[0, 0, 0],
[2, 2, 2],
[4, 4, 4]])
和h:
array([[0, 3, 6],
[0, 3, 6],
[0, 3, 6]])
所以如果你有两个指标，比如说x和y(这就是为什么网格的返回值通常是xx或xs而不是x，在这种情况下，我选择h表示水平!)，那么你可以得到点的x坐标，点的y坐标和该点的值，通过使用:
h[x, y] # horizontal coordinate
v[x, y] # vertical coordinate
data[x, y] # value
这使得跟踪坐标变得更加容易，(更重要的是)您可以将它们传递给需要知道坐标的函数。
稍微长一点的解释
However, np.meshgrid itself isn't often used directly, mostly one just uses one of similar objects np.mgrid or np.ogrid. Here np.mgrid represents the sparse=False and np.ogrid the sparse=True case (I refer to the sparse argument of np.meshgrid). Note that there is a significant difference between np.meshgrid and np.ogrid and np.mgrid: The first two returned values (if there are two or more) are reversed. Often this doesn't matter but you should give meaningful variable names depending on the context.
例如，对于2D网格和matplotlib.pyplot.imshow，将np的第一个返回项命名是有意义的。x和y的网格 np也一样。Mgrid和np. grid。
np。网格和稀疏网格
>>> import numpy as np
>>> yy, xx = np.ogrid[-5:6, -5:6]
>>> xx
array([[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]])
>>> yy
array([[-5],
[-4],
[-3],
[-2],
[-1],
[ 0],
[ 1],
[ 2],
[ 3],
[ 4],
[ 5]])
如前所述，输出与np相比是相反的。meshgrid，这就是为什么我解包为yy, xx而不是xx, yy:
>>> xx, yy = np.meshgrid(np.arange(-5, 6), np.arange(-5, 6), sparse=True)
>>> xx
array([[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]])
>>> yy
array([[-5],
[-4],
[-3],
[-2],
[-1],
[ 0],
[ 1],
[ 2],
[ 3],
[ 4],
[ 5]])
这已经看起来像坐标了，特别是2D图中的x和y线。
可视化:
yy, xx = np.ogrid[-5:6, -5:6]
plt.figure()
plt.title('ogrid (sparse meshgrid)')
plt.grid()
plt.xticks(xx.ravel())
plt.yticks(yy.ravel())
plt.scatter(xx, np.zeros_like(xx), color="blue", marker="*")
plt.scatter(np.zeros_like(yy), yy, color="red", marker="x")
np。Mgrid和密集/丰满的网格
>>> yy, xx = np.mgrid[-5:6, -5:6]
>>> xx
array([[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]])
>>> yy
array([[-5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5],
[-4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4],
[-3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3],
[-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2],
[-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
[ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3],
[ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4],
[ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5]])
这里也一样:输出与np.meshgrid相反:
>>> xx, yy = np.meshgrid(np.arange(-5, 6), np.arange(-5, 6))
>>> xx
array([[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5],
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]])
>>> yy
array([[-5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5],
[-4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4],
[-3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3],
[-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2],
[-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1],
[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
[ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3],
[ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4],
[ 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5]])
与网格不同，这些数组包含-5 <= xx <= 5中的所有xx和yy坐标;-5 <= yy <= 5格。
yy, xx = np.mgrid[-5:6, -5:6]
plt.figure()
plt.title('mgrid (dense meshgrid)')
plt.grid()
plt.xticks(xx[0])
plt.yticks(yy[:, 0])
plt.scatter(xx, yy, color="red", marker="x")
功能
它不仅限于2D，这些函数适用于任意维度(好吧，Python中给函数的参数有最大数量，NumPy允许的最大维度数量):
>>> x1, x2, x3, x4 = np.ogrid[:3, 1:4, 2:5, 3:6]
>>> for i, x in enumerate([x1, x2, x3, x4]):
... print('x{}'.format(i+1))
... print(repr(x))
x1
array([[[[0]]],
[[[1]]],
[[[2]]]])
x2
array([[[[1]],
[[2]],
[[3]]]])
x3
array([[[[2],
[3],
[4]]]])
x4
array([[[[3, 4, 5]]]])
>>> # equivalent meshgrid output, note how the first two arguments are reversed and the unpacking
>>> x2, x1, x3, x4 = np.meshgrid(np.arange(1,4), np.arange(3), np.arange(2, 5), np.arange(3, 6), sparse=True)
>>> for i, x in enumerate([x1, x2, x3, x4]):
... print('x{}'.format(i+1))
... print(repr(x))
# Identical output so it's omitted here.
即使这些也适用于1D，还有两个(更常见的)1D网格创建函数:
np.arange np.linspace
除了start和stop参数，它还支持step参数(甚至是表示步数的复杂steps):
>>> x1, x2 = np.mgrid[1:10:2, 1:10:4j]
>>> x1 # The dimension with the explicit step width of 2
array([[1., 1., 1., 1.],
[3., 3., 3., 3.],
[5., 5., 5., 5.],
[7., 7., 7., 7.],
[9., 9., 9., 9.]])
>>> x2 # The dimension with the "number of steps"
array([[ 1., 4., 7., 10.],
[ 1., 4., 7., 10.],
[ 1., 4., 7., 10.],
[ 1., 4., 7., 10.],
[ 1., 4., 7., 10.]])
应用程序
你特别问了目的，事实上，如果你需要一个坐标系统，这些网格是非常有用的。
例如，如果你有一个计算二维距离的NumPy函数:
def distance_2d(x_point, y_point, x, y):
return np.hypot(x-x_point, y-y_point)
你想知道每个点的距离
>>> ys, xs = np.ogrid[-5:5, -5:5]
>>> distances = distance_2d(1, 2, xs, ys) # distance to point (1, 2)
>>> distances
array([[9.21954446, 8.60232527, 8.06225775, 7.61577311, 7.28010989,
7.07106781, 7. , 7.07106781, 7.28010989, 7.61577311],
[8.48528137, 7.81024968, 7.21110255, 6.70820393, 6.32455532,
6.08276253, 6. , 6.08276253, 6.32455532, 6.70820393],
[7.81024968, 7.07106781, 6.40312424, 5.83095189, 5.38516481,
5.09901951, 5. , 5.09901951, 5.38516481, 5.83095189],
[7.21110255, 6.40312424, 5.65685425, 5. , 4.47213595,
4.12310563, 4. , 4.12310563, 4.47213595, 5. ],
[6.70820393, 5.83095189, 5. , 4.24264069, 3.60555128,
3.16227766, 3. , 3.16227766, 3.60555128, 4.24264069],
[6.32455532, 5.38516481, 4.47213595, 3.60555128, 2.82842712,
2.23606798, 2. , 2.23606798, 2.82842712, 3.60555128],
[6.08276253, 5.09901951, 4.12310563, 3.16227766, 2.23606798,
1.41421356, 1. , 1.41421356, 2.23606798, 3.16227766],
[6. , 5. , 4. , 3. , 2. ,
1. , 0. , 1. , 2. , 3. ],
[6.08276253, 5.09901951, 4.12310563, 3.16227766, 2.23606798,
1.41421356, 1. , 1.41421356, 2.23606798, 3.16227766],
[6.32455532, 5.38516481, 4.47213595, 3.60555128, 2.82842712,
2.23606798, 2. , 2.23606798, 2.82842712, 3.60555128]])
如果在密集网格而不是开放网格中通过，输出将是相同的。NumPys广播使之成为可能!
让我们将结果可视化:
plt.figure()
plt.title('distance to point (1, 2)')
plt.imshow(distances, origin='lower', interpolation="none")
plt.xticks(np.arange(xs.shape[1]), xs.ravel()) # need to set the ticks manually
plt.yticks(np.arange(ys.shape[0]), ys.ravel())
plt.colorbar()
这也是NumPys mgrid和ogrid变得非常方便的时候，因为它允许您轻松地更改网格的分辨率:
ys, xs = np.ogrid[-5:5:200j, -5:5:200j]
# otherwise same code as above
但是，由于imshow不支持x和y输入，因此必须手动更改刻度。如果它能接受x和y坐标就很方便了，对吧?
使用NumPy编写自然处理网格的函数很容易。此外，NumPy、SciPy和matplotlib中有几个函数希望您在网格中传递。
我喜欢图像，所以让我们探索matplotlib.pyplot.contour:
ys, xs = np.mgrid[-5:5:200j, -5:5:200j]
density = np.sin(ys)-np.cos(xs)
plt.figure()
plt.contour(xs, ys, density)
注意，坐标已经正确设置!如果你只传递密度就不是这样了。
或者再举一个使用星相模型的有趣例子(这次我不太关心坐标，我只是用它们来创建一些网格):
from astropy.modeling import models
z = np.zeros((100, 100))
y, x = np.mgrid[0:100, 0:100]
for _ in range(10):
g2d = models.Gaussian2D(amplitude=100,
x_mean=np.random.randint(0, 100),
y_mean=np.random.randint(0, 100),
x_stddev=3,
y_stddev=3)
z += g2d(x, y)
a2d = models.AiryDisk2D(amplitude=70,
x_0=np.random.randint(0, 100),
y_0=np.random.randint(0, 100),
radius=5)
z += a2d(x, y)
虽然这只是“为了看起来”，但与函数模型和拟合相关的几个函数(例如scipy. interpolite .interp2d， Scipy .interpolate.griddata甚至显示使用np.mgrid)的例子，在Scipy等需要网格。其中大多数都使用开放网格和密集网格，但有些只使用其中一种。
幕后故事:
import numpy as np
def meshgrid(x , y):
XX = []
YY = []
for colm in range(len(y)):
XX.append([])
YY.append([])
for row in range(len(x)):
XX[colm].append(x[row])
YY[colm].append(y[colm])
return np.asarray(XX), np.asarray(YY)
让我们以@Sarsaparilla的答案为例:
y = [7, 6, 5]
x = [1, 2, 3, 4]
xx, yy = meshgrid(x , y)
输出:
>>> xx
array([[1, 2, 3, 4],
[1, 2, 3, 4],
[1, 2, 3, 4]])
>>> yy
array([[7, 7, 7, 7],
[6, 6, 6, 6],
[5, 5, 5, 5]])
meshgrid有助于从两个1-D数组的所有点对中创建一个矩形网格。
x = np.array([0, 1, 2, 3, 4])
y = np.array([0, 1, 2, 3, 4])
现在，如果你已经定义了一个函数f(x,y)，你想要将这个函数应用到数组'x'和'y'中所有可能的点的组合，那么你可以这样做:
f(*np.meshgrid(x, y))
比如说，如果你的函数只产生两个元素的乘积，那么这就是笛卡尔积的实现方式，对于大型数组来说是有效的。
此处引用
微软Excel提供:
meshgrid的目的是用x值数组和y值数组创建一个矩形网格。
例如，如果我们想创建一个网格在x和y方向上的0到4之间的每一个整数值上都有一个点。为了创建一个矩形网格，我们需要x和y点的每个组合。
这是25点，对吧?如果我们想为所有这些点创建一个x和y数组，我们可以这样做。
x[0,0] = 0 y[0,0] = 0
x[0,1] = 1 y[0,1] = 0
x[0,2] = 2 y[0,2] = 0
x[0,3] = 3 y[0,3] = 0
x[0,4] = 4 y[0,4] = 0
x[1,0] = 0 y[1,0] = 1
x[1,1] = 1 y[1,1] = 1
...
x[4,3] = 3 y[4,3] = 4
x[4,4] = 4 y[4,4] = 4
这将导致以下x和y矩阵，这样每个矩阵中相应元素的配对就给出了网格中一点的x和y坐标。
x = 0 1 2 3 4 y = 0 0 0 0 0
0 1 2 3 4 1 1 1 1 1
0 1 2 3 4 2 2 2 2 2
0 1 2 3 4 3 3 3 3 3
0 1 2 3 4 4 4 4 4 4
然后我们可以绘制它们来验证它们是否是一个网格:
plt.plot(x,y, marker='.', color='k', linestyle='none')
显然，这是非常乏味的，特别是对于大范围的x和y。相反，meshgrid实际上可以为我们生成这个:我们所需要指定的是唯一的x和y值。
xvalues = np.array([0, 1, 2, 3, 4]);
yvalues = np.array([0, 1, 2, 3, 4]);
现在，当我们调用meshgrid时，我们会自动获得之前的输出。
xx, yy = np.meshgrid(xvalues, yvalues)
plt.plot(xx, yy, marker='.', color='k', linestyle='none')
创建这些矩形网格对许多任务都很有用。在你的文章中提供的例子中，它只是一种在x和y的值范围内采样函数(sin(x**2 + y**2) / (x**2 + y**2))的方法。
由于该函数已在矩形网格上进行采样，因此现在可以将该函数可视化为“图像”。
此外，结果现在可以传递给函数，期望数据在矩形网格(即轮廓)
