Seaborn Heatmap-Tutorial | Python-Datenvisualisierung

Blog

Seaborn Heatmap-Tutorial | Python-Datenvisualisierung

Sie erfahren, was eine Heatmap ist, wie Sie sie erstellen, ihre Farben ändern, ihre Schriftgröße anpassen und vieles mehr, also fangen wir an.



Was ist eine Heatmap?

Die Heatmap ist eine Möglichkeit, die Daten in einer 2-dimensionalen Form darzustellen. Die Datenwerte werden im Diagramm als Farben dargestellt. Das Ziel der Heatmap ist es, eine farbige visuelle Zusammenfassung von Informationen bereitzustellen.

Erstellen Sie eine Heatmap

Um eine Heatmap in Python zu erstellen, können wir die Seaborn-Bibliothek verwenden. Die seaborn-Bibliothek baut auf Matplotlib auf. Die Seaborn-Bibliothek bietet eine High-Level-Datenvisualisierungsschnittstelle, auf der wir unsere Matrix zeichnen können.



Für dieses Tutorial verwenden wir die folgenden Python-Komponenten:

Führen Sie den Befehl pip wie folgt aus, um seaborn zu installieren:



pip install seaborn

Seaborn unterstützt die folgenden Plots:

Okay, lassen Sie uns jetzt eine Heatmap erstellen:

Importieren Sie die folgenden erforderlichen Module:

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

Wir haben die importiert numpy-Modul um ein Array von Zufallszahlen zwischen einem bestimmten Bereich zu generieren, das als Heatmap dargestellt wird.

data = np.random.rand(4, 6)

Es wird ein 2-dimensionales Array mit 4 Zeilen und 6 Spalten erstellt. Jetzt speichern wir diese Array-Werte in der Heatmap. Wir können eine Heatmap erstellen, indem wir die Heatmap-Funktion des seaborn-Moduls verwenden. Dann übergeben wir die Daten wie folgt:

heat_map = sb.heatmap(data)

Mit matplotlib zeigen wir die Heatmap in der Ausgabe an:

plt.show()

Herzliche Glückwünsche! Ihre erste Heatmap ist gerade erstellt!

Heatmap x Häkchen-Beschriftungen entfernen

Die Werte auf der x- und y-Achse für jeden Block in der Heatmap werden als Teilstrichbeschriftungen bezeichnet. Die Teilstrichbeschriftungen werden standardmäßig hinzugefügt. Wenn wir die Tick-Beschriftungen entfernen möchten, können wir das xticklabel- oder ytickelabel-Attribut der Seaborn-Heatmap wie folgt auf False setzen:

heat_map = sb.heatmap(data, xticklabels=False, yticklabels=False)

Heatmap-X-Achsenbeschriftung festlegen

Wir können ein Label in der x-Achse hinzufügen, indem wir das xlabel-Attribut von Matplotlib verwenden, wie im folgenden Code gezeigt:

>>> plt.xlabel('Values on X axis')

Das Ergebnis wird wie folgt sein:

Entfernen Sie die Heatmap und die Häkchen-Beschriftungen

Die Beschriftungen für die y-Achse werden standardmäßig hinzugefügt. Um sie zu entfernen, können wir die yticklabels auf false setzen.

Videoanruf-API für Websites
heat_map = sb.heatmap(data, yticklabels=False)

Y-Achsenbeschriftung der Heatmap festlegen

Sie können die Beschriftung in der y-Achse hinzufügen, indem Sie das ylabel-Attribut von Matplotlib wie gezeigt verwenden:

>>> data = np.random.rand(4, 6) >>> heat_map = sb.heatmap(data) >>> plt.ylabel('Values on Y axis')

Ändern der Heatmap-Farbe

Sie können die Farbe der Seaborn-Heatmap ändern, indem Sie die Farbkarte mit dem cmap-Attribut der Heatmap verwenden.

Betrachten Sie den folgenden Code:

>>> heat_map = sb.heatmap(data, cmap='YlGnBu') >>> plt.show()

Hier ist cmap gleich YlGnBu was für folgende Farbe steht:

In Seaborn Heatmap haben wir drei verschiedene Arten von Colormaps.

  1. Sequentielle Farbkarten
  2. Abweichende Farbpalette
  3. Diskrete Daten

Sequentielle Farbkarte

Die sequentielle Farbabbildung wird verwendet, wenn die Daten von einem niedrigen Wert bis zu einem hohen Wert reichen. Die sequentiellen Colormap-Farbcodes können mit der Funktion heatmap() oder kdeplot() verwendet werden.

Die sequentielle Farbkarte enthält die folgenden Farben:

Dieses Bild stammt von Matplotlib.org .

Sequentielle Cubehelix-Palette

Die Würfelhelix ist eine Form der sequentiellen Farbkarte. Die Cubehelix kommt zum Einsatz, wenn dort die Helligkeit linear erhöht wird und ein geringer Farbtonunterschied besteht.

Die Cubehelix-Palette sieht wie folgt aus:

Sie können diese Palette mit dem cmap-Attribut im Code implementieren:

>>> heat_map = sb.heatmap(data, cmap='cubehelix')

Das Ergebnis wird sein:

Abweichende Farbpalette

Sie können die abweichende Farbpalette verwenden, wenn die hohen und niedrigen Werte in der Heatmap wichtig sind.

Die divergente Palette erstellt eine Palette zwischen zwei HUSL-Farben. Dies bedeutet, dass die abweichende Palette zwei verschiedene Schattierungen in einem Diagramm enthält.

Sie können die abweichende Palette in Seaborn wie folgt erstellen:

import seaborn as sb import matplotlib.pyplot as plt >>> sb.palplot(sb.diverging_palette(200, 100, n=11)) >>> plt.show()

Hier ist 200 der Wert für Palette auf der linken Seite und 100 ist der Code für Palette auf der rechten Seite. Die Variable n definiert die Anzahl der Blöcke. In unserem Fall ist es 11. Die Palette sieht wie folgt aus:

Diskrete Daten

In Seaborn gibt es eine eingebaute Funktion namens mpl_palette, die diskrete Farbmuster zurückgibt. Die Methode mpl_palette zeichnet Werte in einer Farbpalette. Diese Palette ist ein horizontales Array.

Die divergierende Palette sieht wie folgt aus:

Diese Ausgabe wird mit der folgenden Codezeile erreicht:

>>> sb.palplot(sb.mpl_palette('Set3', 11)) >>> plt.show()

Das Argument Set3 ist der Name der Palette und 11 ist die Anzahl der diskreten Farben in der Palette. Die Palplot-Methode von seaborn zeichnet die Werte in einem horizontalen Array der gegebenen Farbpalette.

Text über Heatmap hinzufügen

Um Text über die Heatmap hinzuzufügen, können wir das annot-Attribut verwenden. Wenn annot auf True gesetzt ist, wird der Text in jede Zelle geschrieben. Wenn die Beschriftungen für jede Zelle definiert sind, können Sie die Beschriftungen dem annot-Attribut zuweisen.

Betrachten Sie den folgenden Code:

>>> data = np.random.rand(4, 6) >>> heat_map = sb.heatmap(data, annot=True) >>> plt.show()

Das Ergebnis wird wie folgt sein:

Wir können den Anmerkungswert anpassen, wie wir später sehen werden.

Schriftgröße der Heatmap anpassen

Wir können die Schriftgröße des Heatmap-Textes anpassen, indem wir das font_scale-Attribut des Seaborn wie folgt verwenden:

>>> sb.set(font_scale=2)

Definieren Sie nun die Heatmap und zeigen Sie sie an:

>>> heat_map = sb.heatmap(data, annot=True) >>> plt.show()

Die Heatmap sieht nach dem Vergrößern wie folgt aus:

Seaborn Heatmap-Farbleiste

Die Farbleiste in der Heatmap sieht wie folgt aus:

Java alle Klassen im Paket bekommen

Das Attribut cbar der Heatmap ist ein boolesches Attribut, das, wenn es auf true gesetzt ist, sagt, ob es im Plot erscheinen soll oder nicht. Wenn das Attribut cbar nicht definiert ist, wird der Farbbalken standardmäßig im Diagramm angezeigt. Um den Farbbalken zu entfernen, setzen Sie cbar auf False:

>>> heat_map = sb.heatmap(data, annot=True, cbar=False) >>> plt.show()

Um einen Farbbalkentitel hinzuzufügen, können wir das Attribut cbar_kws verwenden.

Der Code wird wie folgt aussehen:

>>> heat_map = sb.heatmap(data, annot=True, cbar_kws={'label': 'My Colorbar'}) >>> plt.show()

In cbar_kws müssen wir angeben, auf welches Attribut des Farbbalkens wir uns beziehen. In unserem Beispiel beziehen wir uns auf das Label (Titel) des Farbbalkens.

Ebenso können wir die Ausrichtung der Farbe ändern. Die Standardausrichtung ist wie im obigen Beispiel vertikal.

Um einen horizontalen Farbbalken zu erstellen, definieren Sie das Ausrichtungsattribut von cbar_kws wie folgt:

>>> heat_map = sb.heatmap(data, annot=True, cbar_kws={'label': 'My Colorbar', 'orientation': 'horizontal'}) >>> plt.show()

Der resultierende Farbbalken sieht wie folgt aus:

Schriftgröße der Heatmap-Farbleiste ändern

Wenn wir die Schriftgröße aller Komponenten von Seaborn ändern müssen, können Sie das Attribut font_scale von Seaborn verwenden.

Stellen wir die Skala auf 1,8 und vergleichen eine Skala 1 mit 1,8:

>>> sb.set(font_scale=1.8) >>> heat_map = sb.heatmap(data, annot=True, cbar_kws={'label': 'My Colorbar', 'orientation': 'horizontal'}) >>> plt.show()

Dieses Ergebnis für Maßstab 1:

Und die Skala von 1,8 sieht so aus:

Ändern Sie die Drehung der Tick-Achse

Wir können die Drehung der Teilstrichbeschriftungen ändern, indem wir das Rotationsattribut der erforderlichen ytick- oder xtick-Beschriftungen verwenden.

Zuerst definieren wir die Heatmap wie folgt:

>>> heat_map = sb.heatmap(data) >>> plt.show()

Dies ist ein reguläres Diagramm mit Zufallsdaten, wie im vorherigen Abschnitt definiert.

Beachten Sie die ursprünglichen yticklabels in der folgenden Abbildung:

Um sie zu drehen, holen wir uns zuerst die yticklabels der Heatmap und setzen dann die Drehung auf 0:

>>> heat_map.set_yticklabels(heat_map.get_yticklabels(), rotation=0)

In set_yticklabels haben wir zwei Argumente übergeben. Der erste bekommt die yticklabels der Heatmap und der zweite legt die Rotation fest. Das Ergebnis der obigen Codezeile sieht wie folgt aus:

Das Rotationsattribut kann ein beliebiger Winkel sein:

>>> heat_map.set_yticklabels(heat_map.get_yticklabels(), rotation=35)

Fügen Sie Text und Werte auf der Heatmap hinzu

Im vorherigen Abschnitt haben wir nur Werte auf der Heatmap hinzugefügt. In diesem Abschnitt fügen wir Werte zusammen mit dem Text auf der Heatmap hinzu.

Betrachten Sie das folgende Beispiel:

Erstellen Sie zufällige Testdaten:

>>> data = np.random.rand(4, 6)

Erstellen Sie nun ein Array für den Text, den wir auf die Heatmap schreiben:

>>> text = np.asarray([['a', 'b', 'c', 'd', 'e', 'f'], ['g', 'h', 'i', 'j', 'k', 'l'], ['m', 'n', 'o', 'p', 'q', 'r'], ['s', 't', 'u', 'v', 'w', 'x']])

Jetzt müssen wir den Text mit den Werten kombinieren und das Ergebnis als Label in die Heatmap einfügen:

>>> labels = (np.asarray(['{0} {1:.2f}'.format(text,data) for text, data in zip(text.flatten(), data.flatten())])).reshape(4,6)

Okay, hier haben wir die Daten im Text-Array und im Daten-Array übergeben und dann beide Arrays in einfacheren Text abgeflacht und zusammengezippt. Das Ergebnis wird dann umgeformt, um ein weiteres Array derselben Größe zu erstellen, das nun sowohl Text als auch Daten enthält.

Variable wird mit Annot zur Heatmap hinzugefügt:

>>> heat_map = sb.heatmap(data, annot=labels, fmt='')

Das Attribut fmt ist eine Zeichenfolge, die hinzugefügt werden sollte, wenn andere Anmerkungen als True und False hinzugefügt werden.

Beim Plotten dieser Heatmap sieht das Ergebnis wie folgt aus:

Die Arbeit mit Seaborn Heatmaps ist sehr einfach. Ich hoffe, Sie finden das Tutorial nützlich.

Literatur-Empfehlungen

☞ Ist Ihre Django-App langsam? Denken Sie wie ein Datenwissenschaftler, nicht wie ein Ingenieur

☞ Python-Projekt: 3D-Schach in Augmented Reality

☞ 5 häufige Python-Fehler und wie man sie behebt

Erstellen und Bereitstellen einer Python-Webanwendung | Flasche, Postgres & Heroku

☞ Schlangenspiel mit Python-Flüchten (neue Funktionen)

Django 2 Ajax CRUD mit Python 3.7 und jQuery

☞ So programmieren Sie eine GUI-Anwendung (mit Python Tkinter)

Dankeschön.

#Python