Quel est le but de meshgrid dans Python/NumPy?
Quelqu'un peut-il m'expliquer quel est le but de la fonction meshgrid dans Numpy? Je sais que cela crée une sorte de grille de coordonnées pour le tracé, mais je ne vois pas vraiment l'avantage direct de cela.
J'étudie Sebastian Raschka, "Python Machine Learning", et il l'utilise pour tracer les frontières de la décision. Voir entrée 11 ici .
J'ai aussi essayé ce code à partir de la documentation officielle, mais encore une fois, la sortie n'a pas vraiment de sens.
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)
S'il vous plaît, si possible, montrez-moi aussi beaucoup d'exemples du monde réel.
meshgrid a pour but de créer une grille rectangulaire à partir d'un tableau de valeurs x et d'un tableau de valeurs y.
Ainsi, par exemple, si nous voulons créer une grille où nous avons un point pour chaque valeur entière comprise entre 0 et 4 dans les deux directions x et y. Pour créer une grille rectangulaire, nous avons besoin de chaque combinaison des points x et y.
Cela va être 25 points, non? Donc, si nous voulions créer un tableau x et y pour tous ces points, nous pourrions faire ce qui suit.
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
Cela donnerait les matrices x et y suivantes, telles que le couplage de l'élément correspondant dans chaque matrice donne les coordonnées x et y d'un point de la grille.
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
Nous pouvons ensuite les tracer pour vérifier qu’il s’agit d’une grille:
plt.plot(x,y, marker='.', color='k', linestyle='none')
De toute évidence, cela devient très fastidieux, en particulier pour les larges plages de x et y. Au lieu de cela, meshgrid peut en réalité générer cela pour nous: il suffit de spécifier les valeurs uniques x et y.
xvalues = np.array([0, 1, 2, 3, 4]);
yvalues = np.array([0, 1, 2, 3, 4]);
Maintenant, lorsque nous appelons meshgrid, nous obtenons automatiquement la sortie précédente.
xx, yy = np.meshgrid(xvalues, yvalues)
plt.plot(xx, yy, marker='.', color='k', linestyle='none')
La création de ces grilles rectangulaires est utile pour un certain nombre de tâches. Dans l'exemple que vous avez fourni dans votre message, il s'agit simplement d'un moyen d'échantillonner une fonction (sin(x**2 + y**2) / (x**2 + y**2)) sur une plage de valeurs pour x et y.
Comme cette fonction a été échantillonnée sur une grille rectangulaire, elle peut maintenant être visualisée sous la forme d'une "image".
De plus, le résultat peut maintenant être transmis aux fonctions qui attendent des données sur une grille rectangulaire (c'est-à-dire contourf)
Avec l'aimable autorisation de Microsoft Excelle:
Supposons que vous ayez une fonction:
def sinus2d(x, y):
return np.sin(x) + np.sin(y)
et vous voulez, par exemple, voir à quoi cela ressemble dans la plage de 0 à 2 * pi. Comment le ferais-tu? Il np.meshgrid entre:
xx, yy = np.meshgrid(np.linspace(0,2*np.pi,100), np.linspace(0,2*np.pi,100))
z = sinus2d(xx, yy) # Create the image on this grid
et un tel complot ressemblerait à:
import matplotlib.pyplot as plt
plt.imshow(z, Origin='lower', interpolation='none')
plt.show()
Donc, np.meshgrid est juste une commodité. En principe, la même chose pourrait être faite par:
z2 = sinus2d(np.linspace(0,2*np.pi,100)[:,None], np.linspace(0,2*np.pi,100)[None,:])
mais là vous devez être conscient de vos dimensions (supposez que vous en avez plus de deux ...) et de la bonne diffusion. np.meshgrid fait tout cela pour vous.
De plus, meshgrid vous permet de supprimer les coordonnées avec les données si vous voulez, par exemple, effectuer une interpolation mais exclure certaines valeurs:
condition = z>0.6
z_new = z[condition] # This will make your array 1D
alors, comment feriez-vous l'interpolation maintenant? Vous pouvez attribuer x et y à une fonction d'interpolation telle que scipy.interpolate.interp2d. Vous avez donc besoin d'un moyen de savoir quelles coordonnées ont été supprimées:
x_new = xx[condition]
y_new = yy[condition]
et alors vous pouvez toujours interpoler avec les "bonnes" coordonnées (essayez-le sans le maillage et vous aurez beaucoup de code supplémentaire):
from scipy.interpolate import interp2d
interpolated = interp2(x_new, y_new, z_new)
et le maillage d'origine vous permet d'obtenir à nouveau l'interpolation sur la grille d'origine:
interpolated_grid = interpolated(xx, yy)
Ce ne sont là que quelques exemples dans lesquels j’ai utilisé la variable meshgrid. Il pourrait y en avoir beaucoup plus.
meshgrid aide à créer une grille rectangulaire à partir de deux tableaux 1D de toutes les paires de points des deux tableaux.
x = np.array([0, 1, 2, 3, 4])
y = np.array([0, 1, 2, 3, 4])
Maintenant, si vous avez défini une fonction f (x, y) et que vous voulez appliquer cette fonction à toutes les combinaisons possibles de points des tableaux 'x' et 'y', vous pouvez le faire:
f(*np.meshgrid(x, y))
Disons que si votre fonction ne produit que le produit de deux éléments, c’est ainsi qu’un produit cartésien peut être obtenu efficacement pour les tableaux de grande taille.
Référé de ici