Générer un heatmap dans MatPlotLib à l'aide d'un éparpillement de l'ensemble de données

Si vous ne voulez pas d'hexagones, vous pouvez utiliser numpy est histogram2d fonction:

import numpy as np
import numpy.random
import matplotlib.pyplot as plt

# Generate some test data
x = np.random.randn(8873)
y = np.random.randn(8873)

heatmap, xedges, yedges = np.histogram2d(x, y, bins=50)
extent = [xedges[0], xedges[-1], yedges[0], yedges[-1]]

plt.clf()
plt.imshow(heatmap.T, extent=extent, origin='lower')
plt.show()

Cela fait une 50x50 heatmap. Si vous voulez, par exemple, 512x384, vous pouvez mettre bins=(512, 384) dans l'appel à histogram2d.

Exemple:

Au lieu d'utiliser des np.hist2d, qui, en général, produit tout à fait laid histogrammes, je voudrais recycler py-sphviewer, un paquet python pour le rendu des particules de simulations à l'aide d'une adaptative lissage par noyau et qui peut être facilement installé par le programme pep (voir page de documentation). Considérons le code suivant, qui est basé sur l'exemple:

import numpy as np
import numpy.random
import matplotlib.pyplot as plt
import sphviewer as sph
def myplot(x, y, nb=32, xsize=500, ysize=500):   
xmin = np.min(x)
xmax = np.max(x)
ymin = np.min(y)
ymax = np.max(y)
x0 = (xmin+xmax)/2.
y0 = (ymin+ymax)/2.
pos = np.zeros([3, len(x)])
pos[0,:] = x
pos[1,:] = y
w = np.ones(len(x))
P = sph.Particles(pos, w, nb=nb)
S = sph.Scene(P)
S.update_camera(r='infinity', x=x0, y=y0, z=0, 
xsize=xsize, ysize=ysize)
R = sph.Render(S)
R.set_logscale()
img = R.get_image()
extent = R.get_extent()
for i, j in zip(xrange(4), [x0,x0,y0,y0]):
extent[i] += j
print extent
return img, extent
fig = plt.figure(1, figsize=(10,10))
ax1 = fig.add_subplot(221)
ax2 = fig.add_subplot(222)
ax3 = fig.add_subplot(223)
ax4 = fig.add_subplot(224)
# Generate some test data
x = np.random.randn(1000)
y = np.random.randn(1000)
#Plotting a regular scatter plot
ax1.plot(x,y,'k.', markersize=5)
ax1.set_xlim(-3,3)
ax1.set_ylim(-3,3)
heatmap_16, extent_16 = myplot(x,y, nb=16)
heatmap_32, extent_32 = myplot(x,y, nb=32)
heatmap_64, extent_64 = myplot(x,y, nb=64)
ax2.imshow(heatmap_16, extent=extent_16, origin='lower', aspect='auto')
ax2.set_title("Smoothing over 16 neighbors")
ax3.imshow(heatmap_32, extent=extent_32, origin='lower', aspect='auto')
ax3.set_title("Smoothing over 32 neighbors")
#Make the heatmap using a smoothing over 64 neighbors
ax4.imshow(heatmap_64, extent=extent_64, origin='lower', aspect='auto')
ax4.set_title("Smoothing over 64 neighbors")
plt.show()

qui produit l'image suivante:

Comme vous le voyez, les images ont l'air assez sympa, et nous sommes en mesure d'identifier les différentes sous-structures sur elle. Ces images sont construites à la propagation d'un poids donné, pour chaque point à l'intérieur d'un certain domaine, défini par le lissage de la longueur, qui s'est donnée par la distance de la plus proche nb voisin (j'ai choisi de 16, 32 et 64 pour les exemples). Ainsi, plus la densité habituellement, les régions sont répartis dans de petites régions par rapport à la densité plus faible des régions.

La fonction myplot est juste une fonction très simple que j'ai écrit afin de donner les données x,y à py-sphviewer à faire de la magie.

Edit: Pour une meilleure approximation de Alejandro réponse, voir ci-dessous.

Je sais que c'est une vieille question, mais je voulais ajouter quelque chose à Alejandro anwser: Si vous voulez une belle image lissée sans l'aide de py-sphviewer place, vous pouvez utiliser np.histogram2d et appliquer un filtre gaussien (de scipy.ndimage.filters) à la heatmap:

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.cm as cm
from scipy.ndimage.filters import gaussian_filter
def myplot(x, y, s, bins=1000):
heatmap, xedges, yedges = np.histogram2d(x, y, bins=bins)
heatmap = gaussian_filter(heatmap, sigma=s)
extent = [xedges[0], xedges[-1], yedges[0], yedges[-1]]
return heatmap.T, extent
fig, axs = plt.subplots(2, 2)
# Generate some test data
x = np.random.randn(1000)
y = np.random.randn(1000)
sigmas = [0, 16, 32, 64]
for ax, s in zip(axs.flatten(), sigmas):
if s == 0:
ax.plot(x, y, 'k.', markersize=5)
ax.set_title("Scatter plot")
else:
img, extent = myplot(x, y, s)
ax.imshow(img, extent=extent, origin='lower', cmap=cm.jet)
ax.set_title("Smoothing with  $\sigma$ = %d" % s)
plt.show()

Produit:

Le diagramme de dispersion et s=16 tracées sur eachother pour Agape Gal'lo (cliquez pour mieux voir):

---

Une différence que j'ai remarqué avec mon filtre gaussien approche et Alejandro était que sa méthode montre de structures locales, beaucoup mieux que le mien. J'ai donc mis en place un simple voisin le plus proche de la méthode au niveau du pixel. Cette méthode calcule pour chaque pixel de l'inverse de la somme des distances de l' n points les plus proches dans les données. Cette méthode est à un niveau de résolution assez gourmand en ressources et je pense qu'il y a un moyen plus rapide, alors laissez-moi savoir si vous avez des améliorations. De toute façon, voici le code:

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.cm as cm
def data_coord2view_coord(p, vlen, pmin, pmax):
dp = pmax - pmin
dv = (p - pmin) / dp * vlen
return dv
def nearest_neighbours(xs, ys, reso, n_neighbours):
im = np.zeros([reso, reso])
extent = [np.min(xs), np.max(xs), np.min(ys), np.max(ys)]
xv = data_coord2view_coord(xs, reso, extent[0], extent[1])
yv = data_coord2view_coord(ys, reso, extent[2], extent[3])
for x in range(reso):
for y in range(reso):
xp = (xv - x)
yp = (yv - y)
d = np.sqrt(xp**2 + yp**2)
im[y][x] = 1 / np.sum(d[np.argpartition(d.ravel(), n_neighbours)[:n_neighbours]])
return im, extent
n = 1000
xs = np.random.randn(n)
ys = np.random.randn(n)
resolution = 250
fig, axes = plt.subplots(2, 2)
for ax, neighbours in zip(axes.flatten(), [0, 16, 32, 64]):
if neighbours == 0:
ax.plot(xs, ys, 'k.', markersize=2)
ax.set_aspect('equal')
ax.set_title("Scatter Plot")
else:
im, extent = nearest_neighbours(xs, ys, resolution, neighbours)
ax.imshow(im, origin='lower', extent=extent, cmap=cm.jet)
ax.set_title("Smoothing over %d neighbours" % neighbours)
ax.set_xlim(extent[0], extent[1])
ax.set_ylim(extent[2], extent[3])
plt.show()

Résultat:

et la question initiale a été... comment faire pour convertir de dispersion des valeurs de valeurs de grille, à droite?
histogram2d ne compter la fréquence par cellule, cependant, si vous avez d'autres données par cellule que juste la fréquence, vous auriez besoin de plus de travail à faire.

x = data_x # between -10 and 4, log-gamma of an svc
y = data_y # between -4 and 11, log-C of an svc
z = data_z #between 0 and 0.78, f1-values from a difficult dataset

Donc, j'ai un dataset avec Z-résultats pour les coordonnées X et Y. Cependant, j'ai été le calcul de quelques points à l'extérieur de la zone d'intérêt (grands espaces), et des tas de points dans une petite zone d'intérêt.

Oui ici, il devient plus difficile mais aussi plus amusant. Certaines bibliothèques (désolé):

from matplotlib import pyplot as plt
from matplotlib import cm
import numpy as np
from scipy.interpolate import griddata

pyplot est mon moteur graphique d'aujourd'hui,
la cm est une gamme de cartes de couleurs avec quelques initeresting choix.
numpy pour les calculs,
et griddata pour la fixation des valeurs d'une grille fixe.

Le dernier est important, surtout parce que la fréquence de xy des points n'est pas également répartie dans mes données. Tout d'abord, nous allons commencer avec quelques limites montage de mes données et de l'arbitraire de la taille de la grille. Les données d'origine a points de données également en dehors de ces x et y des limites.

#determine grid boundaries
gridsize = 500
x_min = -8
x_max = 2.5
y_min = -2
y_max = 7

Nous avons donc défini une grille avec 500 pixels entre les valeurs min et max de x et y.

Dans mes données, il y a beaucoup plus de 500 valeurs disponibles dans la zone d'un grand intérêt; alors que dans le faible taux d'intérêt de la zone, il y a même pas 200 valeurs dans la grille total; entre les graphiques des limites de x_min et x_max il y a encore moins.

Donc, pour obtenir une belle image, la tâche est d'obtenir une moyenne pour l'intérêt supérieur de valeurs et de combler les lacunes d'ailleurs.

Je définir ma grille de maintenant. Pour chaque xx-yy paire, je veux avoir une couleur.

xx = np.linspace(x_min, x_max, gridsize) # array of x values
yy = np.linspace(y_min, y_max, gridsize) # array of y values
grid = np.array(np.meshgrid(xx, yy.T))
grid = grid.reshape(2, grid.shape[1]*grid.shape[2]).T

Pourquoi la forme étrange? scipy.griddata veut une forme de (n, D).

Griddata calcule une valeur pour chaque point de la grille, par une méthode prédéfini.
- Je choisir "le plus proche" vide", les points de la grille sera remplie avec les valeurs de la voisine la plus proche. C'est comme si les zones avec moins d'informations ont plus de cellules (même si ce n'est pas le cas). On pourrait choisir pour interpoler "linéaire", puis des zones avec moins d'informations, semble moins forte. Question de goût, vraiment.

points = np.array([x, y]).T # because griddata wants it that way
z_grid2 = griddata(points, z, grid, method='nearest')
# you get a 1D vector as result. Reshape to picture format!
z_grid2 = z_grid2.reshape(xx.shape[0], yy.shape[0])

Et hop, nous matplotlib pour afficher l'intrigue

fig = plt.figure(1, figsize=(10, 10))
ax1 = fig.add_subplot(111)
ax1.imshow(z_grid2, extent=[x_min, x_max,y_min, y_max,  ],
origin='lower', cmap=cm.magma)
ax1.set_title("SVC: empty spots filled by nearest neighbours")
ax1.set_xlabel('log gamma')
ax1.set_ylabel('log C')
plt.show()

Autour de l'pointu partie de la Forme de V, vous voyez j'ai fait beaucoup de calculs lors de mes recherches pour le sweet spot, tandis que la moins intéressante de pièces, presque partout ailleurs, ont une résolution inférieure.

Très similaire à @Piti réponse, mais à l'aide de 1 appel, au lieu de 2 pour générer les points:

import numpy as np
import matplotlib.pyplot as plt
pts = 1000000
mean = [0.0, 0.0]
cov = [[1.0,0.0],[0.0,1.0]]
x,y = np.random.multivariate_normal(mean, cov, pts).T
plt.hist2d(x, y, bins=50, cmap=plt.cm.jet)
plt.show()

De sortie:

Voici celui que j'ai fait sur un de 1 Million de points de l'ensemble avec 3 catégories (de couleur Rouge, Vert et Bleu). Voici un lien vers le référentiel si vous souhaitez essayer la fonction. Dépôt Github

histplot(
X,
Y,
labels,
bins=2000,
range=((-3,3),(-3,3)),
normalize_each_label=True,
colors = [
[1,0,0],
[0,1,0],
[0,0,1]],
gain=50)