Hasilkan peta panas di MatPlotLib menggunakan set data sebar

Saya memiliki satu set data X, Y poin (sekitar 10k) yang mudah untuk plot sebagai sebar plot tetapi saya ingin mewakili sebagai peta panas.

Saya melihat contoh-contoh di MatPlotLib dan semuanya tampaknya sudah mulai dengan nilai sel heatmap untuk menghasilkan gambar.

Apakah ada metode yang mengubah sekelompok x, y, semuanya berbeda, menjadi peta panas (di mana zona dengan frekuensi x yang lebih tinggi, y akan menjadi "lebih hangat")?

Jika Anda tidak ingin hexagon, Anda dapat menggunakan histogram2dfungsi numpy :

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()

Ini menghasilkan peta panas 50x50. Jika Anda ingin, katakanlah, 512x384, Anda dapat melakukan bins=(512, 384)panggilan ke histogram2d.

Contoh:

Dalam leksikon Matplotlib , saya pikir Anda ingin plot hexbin .

Jika Anda tidak terbiasa dengan jenis plot ini, itu hanya histogram bivariat di mana xy-plane di-tellellated oleh kisi-kisi segi enam biasa.

Jadi dari histogram, Anda bisa menghitung jumlah titik yang jatuh di setiap segi enam, diskritkan wilayah plot sebagai satu set jendela , tetapkan setiap titik ke salah satu jendela ini; akhirnya, petakan windows ke array warna , dan Anda punya diagram hexbin.

Meskipun lebih jarang digunakan daripada misalnya, lingkaran, atau kuadrat, hexagon adalah pilihan yang lebih baik untuk geometri wadah binning intuitif:

• segi enam memiliki simetri tetangga terdekat (mis., kotak persegi tidak, misalnya, jarak dari titik di perbatasan kotak ke titik di dalam kotak itu tidak sama di mana-mana) dan

• hexagon adalah n-poligon tertinggi yang memberikan tessellation bidang reguler (yaitu, Anda dapat dengan aman memodel ulang lantai dapur Anda dengan ubin berbentuk heksagonal karena Anda tidak akan memiliki ruang kosong antara ubin ketika Anda selesai - tidak berlaku untuk semua lainnya yang lebih tinggi-n, n> = 7, poligon).

( Matplotlib menggunakan istilah heksbin plot; demikian juga (AFAIK) semua perpustakaan petak untuk R ; masih saya tidak tahu apakah ini istilah yang diterima secara umum untuk plot jenis ini, meskipun saya curiga ada kemungkinan bahwa hexbin pendek. untuk heksagonal binning , yang menggambarkan langkah penting dalam menyiapkan data untuk ditampilkan.)

from matplotlib import pyplot as PLT
from matplotlib import cm as CM
from matplotlib import mlab as ML
import numpy as NP

n = 1e5
x = y = NP.linspace(-5, 5, 100)
X, Y = NP.meshgrid(x, y)
Z1 = ML.bivariate_normal(X, Y, 2, 2, 0, 0)
Z2 = ML.bivariate_normal(X, Y, 4, 1, 1, 1)
ZD = Z2 - Z1
x = X.ravel()
y = Y.ravel()
z = ZD.ravel()
gridsize=30
PLT.subplot(111)

# if 'bins=None', then color of each hexagon corresponds directly to its count
# 'C' is optional--it maps values to x-y coordinates; if 'C' is None (default) then 
# the result is a pure 2D histogram 

PLT.hexbin(x, y, C=z, gridsize=gridsize, cmap=CM.jet, bins=None)
PLT.axis([x.min(), x.max(), y.min(), y.max()])

cb = PLT.colorbar()
cb.set_label('mean value')
PLT.show()   

Sunting: Untuk perkiraan jawaban Alejandro yang lebih baik, lihat di bawah.

Saya tahu ini adalah pertanyaan lama, tetapi ingin menambahkan sesuatu ke server Alejandro: Jika Anda ingin gambar yang dihaluskan tanpa menggunakan py-sphviewer, Anda dapat menggunakan np.histogram2ddan menerapkan filter gaussian (dari scipy.ndimage.filters) ke peta panas:

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()

Menghasilkan:

Plot sebar dan s = 16 diplot di atas satu sama lain untuk Agape Gal'lo (klik untuk tampilan yang lebih baik):

Satu perbedaan yang saya perhatikan dengan pendekatan filter gaussian saya dan pendekatan Alejandro adalah bahwa metodenya menunjukkan struktur lokal jauh lebih baik daripada milik saya. Oleh karena itu saya menerapkan metode tetangga terdekat yang sederhana di tingkat piksel. Metode ini menghitung untuk setiap piksel jumlah terbalik dari jarak ntitik terdekat dalam data. Metode ini pada resolusi tinggi komputasi yang cukup mahal dan saya pikir ada cara yang lebih cepat, jadi beri tahu saya jika Anda memiliki perbaikan.

Pembaruan: Seperti yang saya duga, ada metode yang jauh lebih cepat menggunakan Scipy's scipy.cKDTree. Lihat jawaban Gabriel untuk implementasinya.

Bagaimanapun, ini kode saya:

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()

Hasil:

Alih-alih menggunakan np.hist2d, yang secara umum menghasilkan histogram yang sangat jelek, saya ingin mendaur ulang py-sphviewer , paket python untuk rendering simulasi partikel menggunakan kernel smoothing adaptive dan yang dapat dengan mudah dipasang dari pip (lihat dokumentasi halaman web). Pertimbangkan kode berikut, yang didasarkan pada contoh:

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()

yang menghasilkan gambar berikut:

Seperti yang Anda lihat, gambar terlihat cukup bagus, dan kami dapat mengidentifikasi berbagai substruktur di atasnya. Gambar-gambar ini dibangun menyebarkan bobot yang diberikan untuk setiap titik dalam domain tertentu, ditentukan oleh panjang smoothing, yang pada gilirannya diberikan oleh jarak ke tetangga nb lebih dekat (saya telah memilih 16, 32 dan 64 untuk contoh). Jadi, daerah dengan kepadatan lebih tinggi biasanya tersebar di daerah yang lebih kecil dibandingkan dengan daerah dengan kepadatan lebih rendah.

Fungsi myplot hanyalah fungsi yang sangat sederhana yang saya tulis untuk memberikan data x, y ke py-sphviewer untuk melakukan keajaiban.

Jika Anda menggunakan 1.2.x

import numpy as np
import matplotlib.pyplot as plt

x = np.random.randn(100000)
y = np.random.randn(100000)
plt.hist2d(x,y,bins=100)
plt.show()

Seaborn sekarang memiliki fungsi jointplot yang seharusnya bekerja dengan baik di sini:

import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt

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

sns.jointplot(x=x, y=y, kind='hex')
plt.show()

dan pertanyaan awal adalah ... bagaimana cara mengubah nilai sebar ke nilai kotak, kan? histogram2dtidak menghitung frekuensi per sel, namun, jika Anda memiliki data lain per sel dari hanya frekuensi, Anda akan memerlukan beberapa pekerjaan tambahan untuk dilakukan.

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

Jadi, saya punya dataset dengan hasil-Z untuk koordinat X dan Y. Namun, saya menghitung beberapa poin di luar bidang minat (kesenjangan besar), dan banyak poin di bidang minat kecil.

Ya di sini menjadi lebih sulit tetapi juga lebih menyenangkan. Beberapa perpustakaan (maaf):

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

pyplot adalah mesin grafis saya hari ini, cm adalah berbagai peta warna dengan beberapa pilihan initeresting. numpy untuk perhitungan, dan data grid untuk melampirkan nilai ke jaringan tetap.

Yang terakhir ini penting terutama karena frekuensi titik xy tidak terdistribusi secara merata dalam data saya. Pertama, mari kita mulai dengan beberapa batasan yang cocok dengan data saya dan ukuran kisi yang berubah-ubah. Data asli memiliki titik data juga di luar batas x dan y.

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

Jadi kami telah mendefinisikan kisi dengan 500 piksel antara nilai min dan maks x dan y.

Dalam data saya, ada lebih dari 500 nilai yang tersedia di bidang minat tinggi; sedangkan di bidang berbunga rendah, tidak ada bahkan 200 nilai dalam total grid; antara batas-batas grafis x_mindan x_maxbahkan ada lebih sedikit.

Jadi untuk mendapatkan gambar yang bagus, tugasnya adalah untuk mendapatkan rata-rata nilai bunga tinggi dan mengisi celah di tempat lain.

Saya mendefinisikan grid saya sekarang. Untuk setiap pasangan xx-yy, saya ingin memiliki warna.

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

Kenapa bentuknya aneh? scipy.griddata menginginkan bentuk (n, D).

Griddata menghitung satu nilai per titik di grid, dengan metode yang telah ditentukan. Saya memilih "terdekat" - titik grid kosong akan diisi dengan nilai dari tetangga terdekat. Ini terlihat seolah-olah area dengan informasi yang lebih sedikit memiliki sel yang lebih besar (bahkan jika bukan itu masalahnya). Seseorang dapat memilih untuk menginterpolasi "linear", maka area dengan informasi yang lebih sedikit terlihat kurang tajam. Soal rasa, kok.

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])

Dan hop, kami serahkan ke matplotlib untuk menampilkan plot

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()

Di sekitar bagian runcing dari V-Shape, Anda tahu saya melakukan banyak perhitungan selama pencarian saya untuk sweet spot, sedangkan bagian yang kurang menarik hampir di tempat lain memiliki resolusi lebih rendah.

Inilah pendekatan tetangga terdekat Jurgy yang hebat tetapi diimplementasikan menggunakan scipy.cKDTree . Dalam pengujian saya sekitar 100x lebih cepat.

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.cm as cm
from scipy.spatial import cKDTree


def data_coord2view_coord(p, resolution, pmin, pmax):
    dp = pmax - pmin
    dv = (p - pmin) / dp * resolution
    return dv


n = 1000
xs = np.random.randn(n)
ys = np.random.randn(n)

resolution = 250

extent = [np.min(xs), np.max(xs), np.min(ys), np.max(ys)]
xv = data_coord2view_coord(xs, resolution, extent[0], extent[1])
yv = data_coord2view_coord(ys, resolution, extent[2], extent[3])


def kNN2DDens(xv, yv, resolution, neighbours, dim=2):
    """
    """
    # Create the tree
    tree = cKDTree(np.array([xv, yv]).T)
    # Find the closest nnmax-1 neighbors (first entry is the point itself)
    grid = np.mgrid[0:resolution, 0:resolution].T.reshape(resolution**2, dim)
    dists = tree.query(grid, neighbours)
    # Inverse of the sum of distances to each grid point.
    inv_sum_dists = 1. / dists[0].sum(1)

    # Reshape
    im = inv_sum_dists.reshape(resolution, resolution)
    return im


fig, axes = plt.subplots(2, 2, figsize=(15, 15))
for ax, neighbours in zip(axes.flatten(), [0, 16, 32, 63]):

    if neighbours == 0:
        ax.plot(xs, ys, 'k.', markersize=5)
        ax.set_aspect('equal')
        ax.set_title("Scatter Plot")
    else:

        im = kNN2DDens(xv, yv, resolution, neighbours)

        ax.imshow(im, origin='lower', extent=extent, cmap=cm.Blues)
        ax.set_title("Smoothing over %d neighbours" % neighbours)
        ax.set_xlim(extent[0], extent[1])
        ax.set_ylim(extent[2], extent[3])

plt.savefig('new.png', dpi=150, bbox_inches='tight')

Buat array 2 dimensi yang sesuai dengan sel-sel di gambar akhir Anda, disebut say heatmap_cellsdan instantiate sebagai semua nol.

Pilih dua faktor penskalaan yang menentukan perbedaan antara setiap elemen array dalam unit nyata, untuk setiap dimensi, katakan x_scaledan y_scale. Pilih ini sedemikian rupa sehingga semua titik data Anda akan berada dalam batas array peta panas.

Untuk setiap titik data mentah dengan x_valuedan y_value:

heatmap_cells[floor(x_value/x_scale),floor(y_value/y_scale)]+=1

Inilah yang saya buat pada set 1 Juta titik dengan 3 kategori (berwarna Merah, Hijau, dan Biru). Berikut ini tautan ke repositori jika Anda ingin mencoba fungsinya. Github Repo

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)

Sangat mirip dengan jawaban @ Piti , tetapi menggunakan 1 panggilan alih-alih 2 untuk menghasilkan poin:

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()

Keluaran:

Saya khawatir saya sedikit terlambat ke pesta tetapi saya memiliki pertanyaan serupa beberapa waktu lalu. Jawaban yang diterima (oleh @ptomato) membantu saya, tetapi saya juga ingin memposting ini jika itu berguna untuk seseorang.

''' I wanted to create a heatmap resembling a football pitch which would show the different actions performed '''

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

#fixing random state for reproducibility
np.random.seed(1234324)

fig = plt.figure(12)
ax1 = fig.add_subplot(121)
ax2 = fig.add_subplot(122)

#Ratio of the pitch with respect to UEFA standards 
hmap= np.full((6, 10), 0)
#print(hmap)

xlist = np.random.uniform(low=0.0, high=100.0, size=(20))
ylist = np.random.uniform(low=0.0, high =100.0, size =(20))

#UEFA Pitch Standards are 105m x 68m
xlist = (xlist/100)*10.5
ylist = (ylist/100)*6.5

ax1.scatter(xlist,ylist)

#int of the co-ordinates to populate the array
xlist_int = xlist.astype (int)
ylist_int = ylist.astype (int)

#print(xlist_int, ylist_int)

for i, j in zip(xlist_int, ylist_int):
    #this populates the array according to the x,y co-ordinate values it encounters 
    hmap[j][i]= hmap[j][i] + 1   

#Reversing the rows is necessary 
hmap = hmap[::-1]

#print(hmap)
im = ax2.imshow(hmap)

Inilah hasilnya