Lag Varmekart i Python: Matplotlib, Seaborn & Plotly Guide

by
Tweet
Share
Share
Pin
0 Shares

Visualisering er et essensielt verktøy for å tolke data og avdekke innsiktsfull informasjon som kan lede til handling. En effektiv visuell fremstilling lar betrakteren raskt få en oversikt over informasjonen med et enkelt blikk.

Et populært visuelt verktøy for data er et varmekart. I denne artikkelen skal vi utforske hva et varmekart er og hvordan man genererer et ved hjelp av Python og bibliotekene Matplotlib, Seaborn og Plotly.

Hva er et Varmekart?

Kilde: seaborn.pydata.org

Et varmekart er et todimensjonalt bilde som presenterer data i form av en matrise eller et rutenett. Hvert datapunkt er representert med en fargetone. Mørkere farger indikerer høyere verdier, mens lysere farger viser lavere verdier.

Varmekart gjør det enkelt å identifisere mønstre, tendenser og variasjoner i data. De gir en sammendragsvisning av informasjon, som raskt lar brukerne se områder med høye eller lave verdier, klynger eller avvik.

Hvor Brukes Varmekart?

Varmekart er særlig nyttige for å illustrere hvordan verdier endrer seg over et rom eller en overflate. Noen vanlige bruksområder er:

Værmelding

Det mest gjenkjennelige varmekartet for mange er nok et kart som viser temperaturforskjeller over et geografisk område.

Et eksempel på dette er en værmelding fra Daily Express, som bruker et varmekart for å visualisere forventede temperaturer. Dette forenkler forståelsen av hvilke områder som vil være varme, kalde, eller et sted imellom.

Nettside- og Applikasjonsbruk

Kilde: HotJar

Ved å spore musebevegelser, klikk og scrollemønstre, bidrar varmekart til å identifisere populære eller oversette områder på en nettside. Denne informasjonen kan deretter brukes til å forbedre brukeropplevelsen og optimalisere brukergrensesnittet.

Medisinsk Bildediagnostikk

Kilde: researchgate.net

Varmekart brukes for å visualisere områder med høy eller lav aktivitet i kroppen. Dette kan hjelpe med å identifisere anomalier, sykdommer, og vurdere progresjon eller respons på behandling for tilstander som kreft.

Biblioteker for Varmekart i Python

Python er et mye brukt programmeringsspråk for dataanalyse og visualisering, takket være sin enkle syntaks og det store utvalget av biblioteker. Flere biblioteker er tilgjengelige for å generere varmekart i Python, inkludert:

  • Matplotlib – Et populært og fleksibelt bibliotek for datavisualisering. Det er et bibliotek på lavere nivå som tilbyr mange tilpasningsmuligheter, men kan være komplekst å bruke.
  • Seaborn – Dette biblioteket er bygget på toppen av Matplotlib og forenkler mange funksjoner samtidig som det gir bedre visuelle fremstillinger.
  • Plotly – Et bibliotek som tilbyr et brukervennlig API for å lage interaktive varmekart i Python.

I de neste avsnittene skal vi se hvordan du kan lage varmekart med hvert av disse bibliotekene.

Hvordan Generere et Varmekart?

Vi skal nå utforske hvordan du kan lage varmekart med Matplotlib, Seaborn og Plotly. For å skrive koden kommer vi til å bruke Google Colab, en gratis tjeneste som tilbyr et Python-notatbokmiljø i skyen. Det krever ingen oppsett, så du kan enkelt følge med. La oss starte med Matplotlib.

Matplotlib

Vi begynner med å importere Matplotlib biblioteket:

import matplotlib.pyplot as plt

Vi trenger også NumPy for å generere et tilfeldig datasett.

import numpy as np

For å generere datasettet legger vi til følgende kode:

# Setter en seed for reproducerbarhet
np.random.seed(2)

# Genererer en 10x10 matrise med tilfeldige tall mellom 1 og 50
data = np.random.randint(low = 1, high = 50, size = (10, 10))

For å plotte dataene bruker vi `imshow`-metoden, og gir dataene som argument. Vi kan tilpasse visualiseringen med flere valgfrie argumenter.

plt.imshow(data)

Når du kjører denne koden, vil du se et enkelt varmekart.

Dette er en god start, men vi har mange tilpasningsmuligheter. For det første kan vi endre fargene med `cmap`-argumentet til `imshow`. Hvis vi for eksempel vil bruke nyanser av blått, kan vi bruke:

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

En full liste over tilgjengelige fargekart finner du her. Resultatet av koden over vil se slik ut:

Et varmekart er mer informativt om vi har en fargeskala som forklarer hva fargene representerer. Vi legger til en fargeskala med:

plt.colorbar()

Nå skal du få en figur som ser slik ut:

En fargeskala er nyttig, men det kan også være ønskelig å vise de faktiske verdiene i hver celle. Dette gjør vi ved å skrive tekst i cellene 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",
      )

Til slutt legger vi til etiketter på aksene. Vi bruker `plt.xticks()` for x-aksen og `plt.yticks()` for y-aksen. Begge metodene bruker samme argumenter; den eneste forskjellen er hvilken akse som påvirkes.

Første argument er en liste med plasseringene for hakemerkene (som indekser). Neste argument er listen med de faktiske etikettene vi vil vise. Et eksempel:

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)

Det er alt! Nå vet du hvordan du lager et varmekart i Matplotlib. Her er hele kodesnutten:

import numpy as np
import matplotlib.pyplot as plt

# Setter en seed for reproducerbarhet
np.random.seed(2)

# Genererer en 10x10 matrise med tilfeldige tall mellom 1 og 50
data = np.random.randint(low = 1, high = 50, size = (10, 10))

# Lager et plott med blå som farge
plt.imshow(data, cmap = 'Blues')

# Viser en fargeskala
plt.colorbar()

# Legger til tekst i cellene
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",
      )

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

# Legger til etikettene på aksene
plt.xticks(np.arange(len(x_labels)), labels=x_labels)
plt.yticks(np.arange(len(y_labels)), labels=y_labels)

Matplotlib er ikke den enkleste løsningen. Som vi skal se, forenkler andre biblioteker som Seaborn og Plotly prosessen med å lage varmekart.

Seaborn

I denne delen gjenskaper vi forrige eksempel med Seaborn, et bibliotek som er bygget på Matplotlib. Seaborn tilbyr abstrakte funksjoner som forenkler bruken av Matplotlib. For å lage et varmekart, starter vi med å importere de nødvendige bibliotekene:

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

Vi importerer Matplotlib siden Seaborn er avhengig av det. Vi trenger også NumPy for å generere et tilfeldig datasett og til slutt importerer vi Seaborn.

Deretter genererer vi datasettet:

# Setter en seed for reproducerbarhet
np.random.seed(2)

# Genererer en 10x10 matrise med tilfeldige tall mellom 1 og 50
data = np.random.randint(low = 1, high = 50, size = (10, 10))

Etter dette lager vi lister med etikettene for aksene:

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

Så lager vi selve varmekartet ved å kalle `sn.heatmap`.

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

Vi har sendt med flere argumenter til denne funksjonen:

  • `data`: datasettet vi skal visualisere
  • `cmap`: fargeskjema for varmekartet
  • `annot`: spesifiserer om vi skal vise de faktiske verdiene i cellene
  • `yticklabels`: listen med etiketter for den vertikale aksen
  • `xticklabels`: listen med etiketter for den horisontale aksen

Til slutt viser vi plottet:

plt.show()

Dette vil generere følgende varmekart:

Plotly

Prosessen med å lage et varmekart i Plotly ligner på Seaborn. Her er koden for å generere et varmekart i Plotly:

import plotly.express as px
import numpy as np

# Setter en seed for reproducerbarhet
np.random.seed(2)

# Genererer en 10x10 matrise med tilfeldige tall mellom 1 og 50
data = np.random.randint(low = 1, high = 50, size = (10, 10))

# Etiketter for aksene
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 vi ser, genereres varmekartet med `px.imshow()`. Første argument er datasettet som skal vises, deretter kommer valgfrie argumenter:

  • `text_auto` er en boolsk verdi som viser annotasjon i cellene
  • `x` er en liste med etiketter for x-aksen
  • `y` er en liste med etiketter for y-aksen
  • `color_continuous_scale` bestemmer fargeskjemaet som skal brukes

Som du ser er Plotly enklere å bruke enn både Seaborn og Matplotlib. I tillegg er grafene interaktive, i motsetning til de statiske bildene som produseres av de andre bibliotekene.

Her er et skjermbilde av resultatet:

Avsluttende Ord

I denne artikkelen har vi sett hvordan vi kan lage varmekart med Python, gjennom å bruke Matplotlib, Seaborn og Plotly. Vi så også hvordan Seaborn og Plotly tilbyr forenklede abstrakter i forhold til Matplotlib. En viktig anvendelse av varmekart er å spore hvordan folk bruker nettsider.

Du kan nå utforske varmekartverktøy for å se hvor brukerne dine klikker på nettstedet ditt.