[Explained] Hur man skapar Heatmap i Python

Visualisering är ett kraftfullt verktyg för att tolka data och generera värdefulla insikter som kan leda till åtgärder. En väl utformad bild kan ge betraktaren en snabb överblick över informationens kärna.

En vanligt förekommande visualiseringsmetod är värmekartan. I denna artikel kommer vi att utforska vad en värmekarta är och hur du kan skapa den i Python med hjälp av Matplotlib, Seaborn och Plotly.

Vad är en värmekarta?

Källa: seaborn.pydata.org

En värmekarta är en grafisk representation av data i ett tvådimensionellt format, ofta i form av en matris eller ett rutnät. Varje datapunkt representeras av en färgnyans, där mörkare nyanser indikerar högre värden och ljusare nyanser representerar lägre värden.

Värmekartor underlättar identifieringen av mönster, trender och variationer i data. De sammanfattar information på ett sätt som snabbt låter användare se områden med höga eller låga värden, grupperingar eller avvikelser.

Var används värmekartor?

Värmekartor är särskilt användbara för att illustrera hur värden ändras över ett visst område. Några vanliga exempel inkluderar:

Väder

Den mest bekanta typen av värmekarta för många är den som visar temperaturvariationer över geografiska områden.

Ett exempel på en väderprognos, hämtad från Daily Express, visar förväntade temperaturer i form av en värmekarta. Detta gör det lätt att se vilka områden som kommer att vara varma, kalla eller däremellan.

Visar användning av webbplats/app

Källa: HotJar

Genom att registrera musrörelser, klick och scrollbeteenden kan värmekartor användas för att identifiera populära eller förbisedda delar av en webbsida. Denna information kan användas för att förbättra användargränssnittet och användarupplevelsen.

Medicinsk bildbehandling

Källa: researchgate.net

Värmekartor kan visualisera områden med hög eller låg aktivitet i kroppen. Detta kan hjälpa till att upptäcka avvikelser och sjukdomar samt bedöma effekterna av behandling vid tillstånd som cancer.

Bibliotek för att skapa värmekartor i Python

Python är ett omtyckt språk för dataanalys och visualisering, tack vare dess enkla syntax och breda ekosystem av bibliotek. Flera bibliotek i Python erbjuder verktyg för att skapa värmekartor. Dessa inkluderar:

• Matplotlib – Ett välkänt bibliotek för datavisualisering som ger många anpassningsmöjligheter, men kan vara komplext att använda.
• Seaborn – Ett visualiseringsbibliotek som bygger på Matplotlib och förenklar vissa funktioner samtidigt som det ger snyggare visualiseringar.
• Plotly – Ett visualiseringsbibliotek med ett lättanvänt gränssnitt för att skapa interaktiva värmekartor i Python.

I följande avsnitt kommer vi att utforska hur man genererar värmekartor med hjälp av dessa bibliotek.

Hur skapar man en värmekarta?

I detta avsnitt kommer vi att gå igenom hur man genererar värmekartor med Matplotlib, Seaborn och Plotly. För att skriva koden kommer vi att använda Google Colab. Det är en gratis Python-miljö som körs i molnet och kräver ingen installation, vilket gör det enkelt att följa med. Vi börjar med att titta på Matplotlib.

Matplotlib

Vi inleder med att importera Matplotlib-biblioteket.

import matplotlib.pyplot as plt

Vi behöver även NumPy för att generera slumpmässiga data.

import numpy as np

För att skapa datauppsättningen lägger vi till följande kod:

# Skapa en seed för reproducerbarhet
np.random.seed(2)

# Generera en 10 x 10 array med heltal mellan 1 och 50
data = np.random.randint(low = 1, high = 50, size = (10, 10))

För att plotta datan använder vi `imshow`-metoden. Vi skickar in datan som ett argument och kan senare anpassa grafiken med fler argument.

plt.imshow(data)

När du kör koden borde du se en värmekarta.

Det finns många anpassningsalternativ tillgängliga. För att börja kan du ändra färgpaletten med hjälp av argumentet `cmap` i `imshow`. Om du till exempel vill använda olika nyanser av blått kan du skapa grafiken med följande kod:

plt.imshow(data, cmap = 'Blues')

En komplett lista över `cmap`-alternativ finns här. Resultatet av koden ovan blir:

En värmekarta blir mer informativ om det finns en nyckel som förklarar vad färgerna representerar. För att lägga till en färgskala lägger du till följande kod:

plt.colorbar()

Resultatet av detta ger en bild som ser ut så här:

En färgskala är användbar, men ibland vill man även visa de faktiska värdena i de olika cellerna. För att göra detta kan vi skriva ut text i varje cell med `plt.text()`.

for i in range(data.shape[0]):
   for j in range(data.shape[1]):
      plt.text(j, i, '%d' % data[i, j],
         horizontalalignment="center",
         verticalalignment="center",
      )

Det sista vi ska göra med värmekartan är att lägga till etiketter på axlarna. Vi använder `plt.xticks`-funktionen för x-axeln och `plt.yticks`-funktionen för y-axeln. Dessa metoder används på samma sätt, den enda skillnaden är vilken axel varje metod påverkar.

Det första argumentet är en lista över positioner där tickmärken ska placeras, som en rad index. Det andra argumentet är en lista med de faktiska etiketterna. Här är ett exempel på hur vi kan lägga till tickmärken:

x_labels = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
y_labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

plt.xticks(np.arange(len(x_labels)), labels=x_labels)
plt.yticks(np.arange(len(y_labels)), labels=y_labels)

Och det var allt! Så här skapar man en värmekarta i Matplotlib. Hela kodlösningen finns nedan.

import numpy as np
import matplotlib.pyplot as plt

# Skapa en seed för reproducerbarhet
np.random.seed(2)

# Generera en 10 x 10 array med heltal mellan 1 och 50
data = np.random.randint(low = 1, high = 50, size = (10, 10))

# Skapa en graf med blå som färg
plt.imshow(data, cmap = 'Blues')

# Visa en färgskala
plt.colorbar()

# Lägg till värden i varje cell
for i in range(data.shape[0]):
   for j in range(data.shape[1]):
      plt.text(j, i, '%d' % data[i, j],
         horizontalalignment="center",
         verticalalignment="center",
      )

# Skapa listor med etiketter för tickmärken
x_labels = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
y_labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

# Lägg till etiketterna
plt.xticks(np.arange(len(x_labels)), labels=x_labels)
plt.yticks(np.arange(len(y_labels)), labels=y_labels)

Att använda Matplotlib är inte den enklaste lösningen. Som vi kommer att se härnäst förenklar andra bibliotek som Seaborn och Plotly processen att skapa en värmekarta.

Seaborn

I det här avsnittet kommer vi att återskapa det tidigare exemplet med Seaborn. Seaborn är ett bibliotek som bygger på Matplotlib och ger abstraktioner som gör det lättare att arbeta med. För att skapa en värmekarta börjar vi med att importera de bibliotek vi ska använda.

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

Vi importerar Matplotlib eftersom Seaborn behöver det. Vi importerar också NumPy för att skapa en slumpmässig datauppsättning. Slutligen importerar vi Seaborn.

Därefter genererar vi datauppsättningen med hjälp av NumPy.

# Skapa en seed för reproducerbarhet
np.random.seed(2)

# Generera en 10 x 10 array med heltal mellan 1 och 50
data = np.random.randint(low = 1, high = 50, size = (10, 10))

Efter detta skapar vi våra listor med axeltickmärken.

# Tickmarksetiketter
x_labels = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
y_labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

Slutligen skapar vi själva värmekartan genom att anropa `heatmap`-funktionen i modulen `sn`.

hm = sn.heatmap(data = data, cmap = 'Oranges', annot = True, yticklabels = y_labels, xticklabels = x_labels)

Som du ser skickade vi med flera argument. Här är en förklaring för varje argument:

• `data` är den datauppsättning vi vill plotta.
• `cmap` är färgschemat som vi vill att värmekartan ska använda.
• `annot` bestämmer om vi vill lägga till värden i de olika datapunkterna.
• `yticklabels` är listan med etiketter för de vertikala axeltickmärkena.
• `xticklabels` är listan med etiketter för de horisontella axeltickmärkena.

Till sist visar vi plottningen med hjälp av koden:

plt.show()

Detta kommer att generera följande värmekarta:

Plotly

För Plotly är processen liknande den i Seaborn. Här är koden för att skapa en värmekarta i Plotly:

import plotly.express as px
import numpy as np

# Skapa en seed för reproducerbarhet
np.random.seed(2)

# Generera en 10 x 10 array med heltal mellan 1 och 50
data = np.random.randint(low = 1, high = 50, size = (10, 10))

# Tickmarksetiketter
x_labels = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
y_labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

px.imshow(data, text_auto = True, x = x_labels, y = y_labels, color_continuous_scale="greys")

Som du kan se genereras värmekartan på den sista raden med funktionen `px.imshow()`. Denna funktion tar in data att plotta som ett positionsargument och tar även in nyckelordsargument enligt följande:

• `text_auto` är ett booleskt värde som aktiverar text i cellerna när det är satt till `True`.
• `x` är en lista med etiketter för tickmärken på x-axeln.
• `y` är en lista med etiketter för tickmärken på y-axeln.
• `color_continuous_scale` specificerar färgschemat som ska användas för grafen.

Som du ser är Plotly enklare att använda än Seaborn och Matplotlib. Dessutom är grafen som genereras interaktiv jämfört med andra bibliotek som ger statiska bilder.

Här är en skärmdump av slutresultatet:

Slutord

I denna artikel har vi gått igenom hur man skapar värmekartor i Python. Vi har behandlat de viktigaste biblioteken – Matplotlib, Seaborn och Plotly. Vi har även sett hur Seaborn och Plotly ger förenklade abstraktioner över Matplotlib. En viktig användning av värmekartor är att spåra hur människor använder dina webbplatser.

Kolla in värmekartor som visar var dina användare klickar.