Visualisering er en viktig måte å forstå data og trekke informativ og handlingskraftig innsikt. Et godt bilde lar leseren få en grunnleggende følelse av informasjonen med bare et blikk.
En populær visualisering som brukes til å vise data er et varmekart. I denne artikkelen vil jeg forklare et varmekart og hvordan du lager et i Python ved å bruke Matplotlib, Seaborn og Plotly.
Innholdsfortegnelse
Hva er et varmekart?
Kilde: seaborn.pydata.org
Et varmekart er et 2-dimensjonalt bilde som representerer data som en matrise eller rutenett av punkter. En nyanse av et fargeplott representerer hvert datapunkt. Mørkere nyanser representerer høyere verdier enn lysere nyanser.
Varmekart gjør det enkelt å identifisere mønstre, trender og variasjoner i data. De gir oppsummert informasjon som lar brukere raskt se områder med høye eller lave verdier, klynger eller uteliggere.
Hvor brukes varmekart?
Varmekart er nyttige for å vise hvordan verdier varierer over rom. Tilfeller for daglig bruk inkluderer:
Vær
Det mest populære varmekartet de fleste har sett er et bokstavelig varmekart – som viser hvordan temperaturen varierer over forskjellige steder.
Dette er et eksempel på værmelding fra Daily Express viser de forventede temperaturene som et varmekart. Dette gjør det lettere å visualisere hvilke steder som vil være varme, kalde eller i mellom.
Viser bruk av nettsted/app
Kilde: HotJar
Gjennom sporing av musebevegelser, klikk og rullemønstre hjelper varmekart å identifisere populære eller forsømte områder på en nettside. Dette kan deretter brukes til å optimalisere brukergrensesnitt og forbedre brukeropplevelsen.
Medisinsk bildebehandling
Kilde: researchgate.net
Varmekart visualiserer områder med høy eller lav aktivitet i kroppen. Dette kan identifisere anomalier og sykdommer og vurdere progresjon eller respons på behandling ved tilstander som kreft.
Biblioteker for å lage varmekart i Python
Python er et populært språk for dataanalyse og visualisering. Dette er på grunn av dens enkle syntaks og omfattende økosystem. Det er flere biblioteker du kan bruke til å lage varmekart i Python. Disse inkluderer:
- Matplotlib – Et populært datavisualiseringsbibliotek. Det er et bibliotek på lavt nivå som gir flere tilpasningsmuligheter, men som er komplisert.
- Seaborn – Dette visualiseringsbiblioteket er bygget på toppen av Matplotlib og forenkler noen av funksjonene samtidig som det gir bedre visualiseringer.
- Plotly – Dette er et visualiseringsbibliotek som gir et brukervennlig API for å lage Heatmaps i Python.
I den neste delen vil vi utforske hvordan du lager varmekart ved å bruke alle disse bibliotekene.
Hvordan generere et varmekart?
I denne delen vil jeg utforske hvordan du lager varmekart ved å bruke Matplotlib, Seaborn og Plotly. For å kode kommer jeg til å bruke Google Colab. Det er en gratis-å-bruke forekomst av en Python Notebook som bruker Google Infrastructure til å kjøre koden din. Den krever ingen oppsett, så du kan også bruke den til å følge med. Til å begynne med vil vi først dekke Matplotlib.
Matplotlib
For å begynne, starter vi med å importere Matplotlib-biblioteket.
import matplotlib.pyplot as plt
Vi vil også trenge NumPy for å generere et tilfeldig datasett.
import numpy as np
For å generere datasettet legger vi til følgende kode:
# Creating a seed for reproducibility np.random.seed(2) # Generating 10 x 10 array of integers between 1 and 50 data = np.random.randint(low = 1, high = 50, size = (10, 10))
For å plotte dataene bruker vi imshow-metoden. Vi sender inn data som argument. Vi kan gjøre mer ved å videreføre ytterligere argumenter vi kommer inn på senere.
plt.imshow(data)
Hvis du kjører cellen, bør du se et varmekart.
Selv om dette er flott, er det mange tilpasningsalternativer tilgjengelige for deg. For det første kan du endre fargen som brukes i bildet ved å bruke cmap-argumentet som du sender til imshow. For eksempel, hvis du ønsker å endre fargen som brukes av varmekartet til forskjellige nyanser av blått, vil du generere plottet med følgende.
plt.imshow(data, cmap = 'Blues')
Den fullstendige listen over cmap-alternativer er funnet her. Uansett, resultatet av ovenstående vil være:
Et varmekart ville vært mer nyttig hvis det var en nøkkel for å forklare hva fargene representerte. For å gjøre dette, legg til følgende kode:
plt.colorbar()
Etter dette skal du få en figur som ser slik ut:
En fargelinje er nyttig, men i noen tilfeller kan det være lurt å kommentere de forskjellige verdiene slik at seeren kan se nøyaktig hva som er representert. For å gjøre dette, skriver du tekst i hver av cellene ved å bruke 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 siste vi skal gjøre med varmekartet er å sette tick-etikettene på aksene. Vi vil bruke plt.xticks-funksjonen for x-aksen og plt.yticks-funksjonen for y-aksen. Disse metodene kalles på samme måte; den eneste forskjellen er aksen hver metode påvirker.
Det første argumentet er listen over steder å sette inn haker. Dette er representert som en rekke indekser. Følgende argument er den faktiske listen over etiketter som vil bli satt inn. Her er et eksempel på hvordan vi kan sette inn haker:
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)
Og det er det! Det er slik du lager et varmekart i Matplotlib. Den komplette kodeløsningen er beskrevet nedenfor.
import numpy as np
import matplotlib.pyplot as plt
# Creating a seed for reproducibility
np.random.seed(2)
# Generating 10 x 10 array of integers between 1 and 50
data = np.random.randint(low = 1, high = 50, size = (10, 10))
# Creating a plot with blue as a color
plt.imshow(data, cmap = 'Blues')
# Displaying a color bar
plt.colorbar()
# Annotating values
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",
)
# Creating lists of tick labels
x_labels = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J']
y_labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']
# Adding the tick labels
plt.xticks(np.arange(len(x_labels)), labels=x_labels)
plt.yticks(np.arange(len(y_labels)), labels=y_labels)
Å bruke Matplotlib er imidlertid ikke den enkleste løsningen. Som vi skal se videre, forenkler andre biblioteker, som Seaborn og Matplotlib, prosessen med å bygge et varmekart.
Seaborn
I denne delen vil vi gjenskape det forrige eksemplet med Seaborn. Seaborn er et bibliotek som bygger på toppen av Matplotlib. Det gir abstraksjoner som gjør det lettere å jobbe med. For å lage et varmekart starter vi med å importere bibliotekene vi skal bruke.
import matplotlib.pyplot as plt import numpy as np import seaborn as sn
Vi importerte Matplotlib fordi Seaborn krever det. Deretter må vi også importere NumPy for å generere et tilfeldig datasett. Til slutt må vi importere Seaborn.
Deretter genererer vi datasettet ved hjelp av NumPy.
# Creating a seed for reproducibility np.random.seed(2) # Generating 10 x 10 array of integers between 1 and 50 data = np.random.randint(low = 1, high = 50, size = (10, 10))
Etter å ha gjort dette, lager vi våre lister over hakeetiketter.
# Tick labels 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å til slutt lager vi selve varmekartet ved å kalle varmekartfunksjonen til sn-modulen.
hm = sn.heatmap(data = data, cmap = 'Oranges', annot = True, yticklabels = y_labels, xticklabels = x_labels)
Som du kan se, vedtok vi flere argumenter. Her er en forklaring for hver:
- data er datasettet vi ønsker å plotte
- cmap er fargeskjemaet vi vil at varmekartet skal lages ved hjelp av
- annot angir om vi ønsker å kommentere datapunktene med deres faktiske verdi
- yticklabels er listen over etiketter vi ønsker for den vertikale aksen
- xticklabels er listen over etiketter for horisontale aksemerker.
Til slutt viser vi plottet ved hjelp av koden:
plt.show()
Dette vil generere følgende varmekart:
Plott
For Plotly ligner prosessen på Seaborn. Her er kodeoversikten for å lage et varmekart i Plotly:
import plotly.express as px import numpy as np # Creating a seed for reproducibility np.random.seed(2) # Generating 10 x 10 array of integers between 1 and 50 data = np.random.randint(low = 1, high = 50, size = (10, 10)) # Tick labels 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, genereres varmekartet i den siste linjen ved hjelp av funksjonen px.imshow(). Denne funksjonen tar inn dataene for å plotte som et posisjonsargument. I tillegg tar det søkeordargumentet som følger:
- text_auto er en boolsk som aktiverer merknaden når den er satt til sann
- x er en liste over x-akse-merker
- y er en liste over hakeetiketter på y-aksen
- color_continuous_scale bestemmer fargeskjemaet som brukes for grafen.
Som du kan se, er Plotly enklere enn Seaborn og Matplotlib. I tillegg er grafen som genereres interaktiv sammenlignet med andre biblioteker som produserer statiske bilder.
Her er skjermbildet for det endelige resultatet:
Siste ord
I denne artikkelen dekket vi hvordan du lager varmekart i Python. Vi dekket hovedbibliotekene – Matplotlib, Seaborn og Plotly. Vi så også hvordan Seaborn og Plotly gir forenklede abstraksjoner over Matplotlib. En kritisk bruk av Heatmaps er å spore hvordan folk bruker nettsidene dine.
Deretter kan du sjekke ut varmekartverktøy som forteller deg hvor brukerne dine klikker.