[PYTHON] Probieren Sie die neuesten Seaborn-APIs aus, um Ihre Datenvisualisierungsfähigkeiten zu verbessern [Visualization Uncle, 2020/9 / 9-ver 0.11.0]
Eine neue Version von seaborn erschien am 9. September 2020. Dieses Mal werde ich auf die Visualisierung zurückblicken, während ich eine solche Version 0.11.0 verwende.
Ich möchte alle APIs in Bezug auf die offizielle Seaborn-Galerie und -Funktionen verwenden.
Wenn Sie nur an Visualisierung interessiert sind, fliegen Sie in die Mitte
Da es lang ist, suchen Sie bitte mit Strg + F.
Überprüfungsumgebung
conda create -n eda python==3.8 conda activate eda
notebook==6.1.4 ipykernel==5.3.4
seaborn==0.11.0 pandas==1.1.2 matplotlib==3.3.2 statsmodels==0.12.0 scipy==1.5.2 scikit-learn==0.23.2 numpy==1.19.2
Unterschied zur Vorgängerversion
・ Überprüfung des Verteilungsvisualisierungscodes ・ Anpassung der Farbkarte ・ Hinzufügen von dis-, hist-, ecdf-Funktionen und -Funktionen -Rezension der kde- und rug-Funktionen (Löschen von Teilen, die von Statistikmodellen berechnet wurden, Glättung kann durch bw_adj angepasst werden, log_scale-Konvertierung kann als Verarbeitung ausgewählt werden) -Sie können jetzt hist mit Jointplot auswählen ・ Unterstützt sowohl vertikale als auch horizontale Daten ・ Oben + geringfügige Änderungen
Ich habe vor der neuen Version 0.10.1 verwendet, aber set_theme wurde hinzugefügt, bevor ich es wusste, und die Einstellung wurde viel einfacher.
Vom Update veraltete Elemente
・ Displot wird in Zukunft verschwinden. Bitte wechseln Sie so schnell wie möglich zur Funktion dis, hist
Was ist Seaborn
Ein kurzer Rückblick auf Seaborn
seaborn ist eine Hülle für matplotlib, ein Paket, das Code einfach und schön zeichnet. Matplot läuft dahinter, aber das Schreiben des Codes wird viel einfacher und Sie können komplizierte Zahlen in einer Zeile ausdrücken. Einige Funktionen führen auch vorverarbeitungsähnliche Filter und Berechnungen durch, sodass ich der Meinung bin, dass sie auch für EDA geeignet sind.
Meeresgeborener Gedanke
Vorstellung der interessanten Ideen von Seaborn
Seaborn entwirft Zeichenmethoden aus den beiden Perspektiven von Achsen und Figuren. Die Gruppierung der zu zeichnenden Funktionen ist wie in der Abbildung gezeigt, und die detaillierte Zeichnung (durch die Funktion auf der Achsenseite) kann gemeinsam durch rel, dis, cat (Funktion auf der Bildseite) gesteuert werden. Natürlich können Sie es auch verwenden, indem Sie einzelne Funktionen aufrufen.
Ist das Skript nicht einfacher zu verstehen, wenn Sie mit einer kleinen Funktion zeichnen?
In der Funktion auf der Bildseite, die gemeinsam verwaltet wird, können Sie automatisch die Anzahl der zu zeichnenden Leinwände generieren, die Gruppierungsverarbeitung durchführen und die Zeicheneinheit (Facette) teilen.
Auch in den Funktionen auf der Achsenseite (sofern nicht anders angegeben) ・ Es ist schwierig, den Namen der Achse zu ändern ・ Die Legende ist in der Abbildung dargestellt.
Es gibt Probleme wie. Wenn es sich um eine Funktion auf der Figurenseite handelt, behandeln Sie die Achse und den Präzedenzfall als verschiedene Dinge. Mit set_axis_labels usw. können Sie Beschriftungen und Präzedenzfälle einfach in einer Zeile steuern.
Es ist sichtbarer als das !!
Der Inhalt der Einleitung ist grob zweigeteilt
· Erste Optionen (Farbe, Achse, Legende usw.) ・ Führt hauptsächlich rel, dis, cat auf der Seite der Hauptfigur ein ・ Einführung in das erweiterte Zeichnen
Ich würde es gerne unterteilen
[Opt-0] Optionale Geschichte
Indem Sie die optionale Geschichte im Voraus mit nur einem Überblick kennenlernen Erhöhen Sie die Leichtigkeit der Eingabe nachfolgender Diagramme
Lassen Sie uns überprüfen, ob die neueste Version überhaupt enthalten ist
import pandas as pd
from matplotlib.pyplot as plt
%matplotlib inline
import seaborn as sns
print(sns.__version__)
0.11.0
[Opt-1] Daten anrufen
Wenn Sie berühmte Daten einfach verwenden möchten Da die von seaborn unterstützten Daten auf github gespeichert sind](https://github.com/mwaskom/seaborn-data), Sie können die Daten auswählen, die Sie verwenden möchten, und sie mit load_dataset aufrufen Aufgerufene Daten können im Pandas-Datenrahmenformat bearbeitet werden
penguins = sns.load_dataset("penguins")
[Opt-2] Zeichnungsthema festlegen
Wählen Sie das Thema aus, das Sie verwenden möchten, während Sie das aktuelle Thema überprüfen
sns.set_theme
<function seaborn.rcmod.set_theme(context='notebook', style='darkgrid', palette='deep', font='sans-serif', font_scale=1, color_codes=True, rc=None)>
Stil steuert den Farbton des Diagrammhintergrunds
white, dark, whitegrid, darkgrid
Palette passt das Farbmuster von Grafikfiguren an
'Accent', 'Accent_r', 'Blues', 'Blues_r', 'BrBG', 'BrBG_r', 'BuGn', 'BuGn_r', 'BuPu', 'BuPu_r', 'CMRmap',
'CMRmap_r', 'Dark2', 'Dark2_r', 'GnBu', 'GnBu_r', 'Greens', 'Greens_r', 'Greys', 'Greys_r', 'OrRd', 'OrRd_r',
'Oranges', 'Oranges_r', 'PRGn', 'PRGn_r', 'Paired', 'Paired_r', 'Pastel1', 'Pastel1_r', 'Pastel2', 'Pastel2_r',
'PiYG', 'PiYG_r', 'PuBu', 'PuBuGn', 'PuBuGn_r', 'PuBu_r', 'PuOr', 'PuOr_r', 'PuRd', 'PuRd_r', 'Purples',
'Purples_r', 'RdBu', 'RdBu_r', 'RdGy', 'RdGy_r', 'RdPu', 'RdPu_r', 'RdYlBu', 'RdYlBu_r', 'RdYlGn', 'RdYlGn_r',
'Reds', 'Reds_r', 'Set1', 'Set1_r', 'Set2', 'Set2_r', 'Set3', 'Set3_r', 'Spectral', 'Spectral_r', 'Wistia',
'Wistia_r', 'YlGn', 'YlGnBu', 'YlGnBu_r', 'YlGn_r', 'YlOrBr', 'YlOrBr_r', 'YlOrRd', 'YlOrRd_r', 'afmhot',
'afmhot_r', 'autumn', 'autumn_r', 'binary', 'binary_r', 'bone', 'bone_r', 'brg', 'brg_r', 'bwr', 'bwr_r',
'cividis', 'cividis_r', 'cool', 'cool_r', 'coolwarm', 'coolwarm_r', 'copper', 'copper_r', 'crest', 'crest_r',
'cubehelix', 'cubehelix_r', 'flag', 'flag_r', 'flare', 'flare_r', 'gist_earth', 'gist_earth_r', 'gist_gray',
'gist_gray_r', 'gist_heat', 'gist_heat_r', 'gist_ncar', 'gist_ncar_r', 'gist_rainbow', 'gist_rainbow_r',
'gist_stern', 'gist_stern_r', 'gist_yarg', 'gist_yarg_r', 'gnuplot', 'gnuplot2', 'gnuplot2_r', 'gnuplot_r',
'gray', 'gray_r', 'hot', 'hot_r', 'hsv', 'hsv_r', 'icefire', 'icefire_r', 'inferno', 'inferno_r', 'jet',
'jet_r', 'magma', 'magma_r', 'mako', 'mako_r', 'nipy_spectral', 'nipy_spectral_r', 'ocean', 'ocean_r',
'pink', 'pink_r', 'plasma', 'plasma_r', 'prism', 'prism_r', 'rainbow', 'rainbow_r', 'rocket', 'rocket_r',
'seismic', 'seismic_r', 'spring', 'spring_r', 'summer', 'summer_r', 'tab10', 'tab10_r', 'tab20', 'tab20_r',
'tab20b', 'tab20b_r', 'tab20c', 'tab20c_r', 'terrain', 'terrain_r', 'turbo', 'turbo_r', 'twilight',
'twilight_r', 'twilight_shifted', 'twilight_shifted_r', 'viridis', 'viridis_r', 'vlag', 'vlag_r',
'winter', 'winter_r'
sns.set_theme(style="dark",palette='Accent')
df = sns.load_dataset("penguins")
sns.displot(df.flipper_length_mm)
[Opt-3] Änderung der Achsenbeschriftungsachse
g = sns.displot(df.flipper_length_mm)
g.set_axis_labels("Xaxis", "Yaxis")
Sie können die Form von außen überschreiben
Das Achsenetikett kann auch gedreht werden
g = sns.displot(df.flipper_length_mm)
g.set_axis_labels("Xaxis", "Yaxis")
g.set_xticklabels(rotation=-45)
Wenn Sie den Etikettenabstand in 20 Schritten ändern möchten
g.set_xticklabels(step=20)
Andere Methoden, die verwendet werden können
[Opt-4] Legendenzeichnung und Farbcodierung
Die Farbcodierung wird in der Funktion durch den Farbton angegeben
In den Achsen funktionieren
df = sns.load_dataset("iris")
sns.scatterplot(data=df,x='sepal_length',y='sepal_width',hue='species')
Die Legende geht automatisch hinein, Wenn Sie die Funktion auf der Bildseite verwenden, erlischt sie automatisch
df = sns.load_dataset("iris")
sns.relplot(data=df,x='sepal_length',y='sepal_width',hue='species',kind='scatter')
[Opt-5] Mehrfachzeichnung und Legende
Ich möchte ein Streudiagramm zeichnen, aber manchmal möchte ich für jede Gruppe ein Streudiagramm zeichnen Mit FacetGrid können mehrere Datenzeichnungen erstellt werden Welche Achse gruppiert werden soll, wird durch Spalte angegeben (Spalte ist Spalte anstelle von Farbe) Die Anzahl der Zeichenbereiche wird automatisch aus dem Wert der qualitativen Variablen der zu gruppierenden Achse ermittelt.
df = sns.load_dataset("penguins")
sns.FacetGrid(df,col='species')
Dem erstellten Zeichenbereich zuordnen
df = sns.load_dataset("penguins")
g=sns.FacetGrid(df,col='species')
g.map_dataframe(sns.scatterplot,x='flipper_length_mm',y='bill_depth_mm',hue="sex")
Wenn Sie eine Legende möchten, fügen Sie sie später mit add_legend hinzu
df = sns.load_dataset("penguins")
g=sns.FacetGrid(df,col='species')
g.map_dataframe(sns.scatterplot,x='flipper_length_mm',y='bill_depth_mm',hue="sex")
g.set_axis_labels('flipper_length_mm','bill_depth_mm')
g.add_legend()
Wenn Sie eine weitere Zeichenachse hinzufügen möchten, können Sie diese weiter unterteilen, indem Sie sie in der Zeile von FacetGrid angeben.
tips = sns.load_dataset("tips")
g = sns.FacetGrid(tips, col="time", row="sex")
g.map(sns.scatterplot, "total_bill", "tip")
[Opt-6] Ich möchte einen Titel für das Ganze
Wenn Sie dem Ganzen anstelle jedes Rasters einen Titel geben, zeigen Sie ihn mit Untertitel an Da matplotlib hinterherläuft, können Sie auch suptitle verwenden
df = sns.load_dataset("penguins")
g=sns.FacetGrid(df,col='species')
g.map_dataframe(sns.scatterplot,x='flipper_length_mm',y='bill_depth_mm',hue="sex")
g.set_axis_labels('flipper_length_mm','bill_depth_mm')
g.add_legend()
g.fig.suptitle('suptitle',y=1.1,x=0,size=18)
[Opt-7] Ich möchte, dass Sie Variablen als Vorverarbeitung protokollieren
Der Wertebereich ist zu breit, um verstanden zu werden
planets = sns.load_dataset("planets")
sns.relplot(data=planets,x="distance", y="orbital_period",hue="year",palette='nipy_spectral')
Vorverarbeitung des Werts durch Angabe der Skala
planets = sns.load_dataset("planets")
g=sns.relplot(data=planets,x="distance", y="orbital_period",hue="year",palette='nipy_spectral')
g.set(xscale="log", yscale="log")
[Opt-8] Ich möchte, dass Sie die Stange der Welle löschen
Das Hintergrundraster verschwindet im Thema, aber die Balken der X- und Y-Achse verschwinden nicht
sns.set_theme(style="white")
planets = sns.load_dataset("planets")
g=sns.relplot(data=planets,x="distance", y="orbital_period",hue="year",palette='nipy_spectral')
g.set(xscale="log", yscale="log")
Mit Verzweiflung löschen
sns.set_theme(style="white")
planets = sns.load_dataset("planets")
g=sns.relplot(data=planets,x="distance", y="orbital_period",hue="year",palette='nipy_spectral')
g.set(xscale="log", yscale="log")
g.despine(left=True, bottom=True)
[Opt-9] Geben Sie xlim und ylim an
sns.set_theme(style="dark",palette='Accent')
df = sns.load_dataset("penguins")
g=sns.displot(df.flipper_length_mm)
g.set(xlim=(0, 300), ylim=(0, 100))
Oder stellen Sie es auf der FacetGrid-Seite ein
sns.FacetGrid(df,col='species',xlim=[0,10],ylim=[0,10])
[Main-0] Einführung in die Haupthandlung
[Main-1] Streuung und Linie durch Relplot
[Main-1.1] Standard rel
sns.set_theme(style="whitegrid")
planets = sns.load_dataset("planets")
g=sns.relplot(data=planets,x="distance", y="orbital_period",palette='Dark2_r')
g.set(xscale="log", yscale="log")
Wenn standardmäßig ausgeführt, wird es gestreut
sns.set_theme(style="whitegrid")
planets = sns.load_dataset("planets")
g=sns.relplot(data=planets,x="distance", y="orbital_period",palette='Dark2_r',kind='scatter')
g.set(xscale="log", yscale="log")
Gleiches gilt auch dann, wenn die Streuung nach Art angegeben ist
[Main-1.2] rel Artspezifikation
Wenn Sie eine Linie mit Art angeben, werden die Punkte verbunden und linearisiert
sns.set_theme(style="whitegrid")
planets = sns.load_dataset("planets")
g=sns.relplot(data=planets,x="distance", y="orbital_period",palette='Dark2_r',kind='line')
g.set(xscale="log", yscale="log")
[Main-1.3] Ändern Sie die Größe der Streuung entsprechend dem Wert (Blasendiagramm).
Ich möchte den Wert des Streudiagramms entsprechend dem Wert wie Blasendiagramm ändern Geben Sie in diesem Fall die Datenzeichenfolge an, die den Wert im Argument size enthält. Übergeben Sie die oberen und unteren Grenzen für Größen nach Liste oder Tupel
planets = sns.load_dataset("planets")
cmap = sns.cubehelix_palette(rot=-.2, as_cmap=True)
g = sns.relplot(data=planets,x="distance", y="orbital_period",hue="year", size="mass",palette='nipy_spectral', sizes=(10, 300))
g.set(xscale="log", yscale="log")
[Main-1.4] Ändern Sie die Ausgabegröße der Abbildung
Bedienen Sie die Größe der Ausgabefigur aus der Höhe
planets = sns.load_dataset("planets")
cmap = sns.cubehelix_palette(rot=-.2, as_cmap=True)
g = sns.relplot(data=planets,x="distance", y="orbital_period",hue="year", size="mass",palette='nipy_spectral', sizes=(10, 300),height=10)
g.set(xscale="log", yscale="log")
[Main-1.5] Zuverlässiger Online-Abschnitt
Einige Daten, die im Streudiagramm schwer zu verstehen sind
fmri = sns.load_dataset("fmri")
sns.relplot(data=fmri,x="timepoint", y="signal", hue="event",kind='scatter')
Mit Linie leicht zu verstehen
fmri = sns.load_dataset("fmri")
sns.relplot(data=fmri,x="timepoint", y="signal", hue="event",kind='line')
Das Vertrauensintervall wird durch ci angegeben. Sie können sd oder eine reelle Zahl übergeben. Wenn es sich um eine reelle Zahl handelt, entspricht dies einem Konfidenzintervall von 〇%. sd verwendet den vom Beobachtungsort berechneten sd so wie er ist
fmri = sns.load_dataset("fmri")
sns.relplot(data=fmri,x="timepoint", y="signal", hue="event",kind='line',ci=20)
Angegeben als 20% -Konfidenzintervall
[Main-1.6] Markierungsbezeichnung
Sie können auch Markierungen für jeden Ereignispunkt hinzufügen und den Vertrauensbereich zu einem Stick anstelle eines Bereichs machen.
sns.relplot(data=fmri, x="timepoint", y="signal", hue="event", err_style="bars", ci=95,markers=True,kind='line')
[Main-1.7] Erhöhen Sie die Anzahl der Linien auf der angegebenen Analyseachse
Wie die zuvor eingeführte Größe zum Zeitpunkt der Streuung kann die Analyseachse nach Stil unterteilt werden.
fmri = sns.load_dataset("fmri")
sns.relplot(data=fmri,x="timepoint", y="signal", hue="region", style="event",kind='line')
Natürlich können Sie auch die Größe angeben
fmri = sns.load_dataset("fmri")
sns.relplot(data=fmri,x="timepoint", y="signal", hue="region", size="event", kind='line')
[Main-1.8] Teilen Sie den Bildschirm durch die angegebene Analyseachse
Wenn Sie den Zeichenbildschirm selbst teilen möchten, geben Sie die Achse an, die Sie in Spalte teilen möchten
fmri = sns.load_dataset("fmri")
sns.relplot(data=fmri,x="timepoint", y="signal", hue="region", col="event", kind='line')
Beim Zeichnen mit mehreren Achsen kann facet_kws angeben, ob die Skalen für die x- und y-Achse in jeder Abbildung gemeinsam genutzt werden sollen.
fmri = sns.load_dataset("fmri")
sns.relplot(data=fmri,x="timepoint", y="signal", hue="region", col="event", kind='line',facet_kws=dict(sharey=False,sharex=False))
Achten Sie darauf, das Etikett nicht zu löschen und ein Überraschungsdiagramm zu erhalten
Wenn Sie es wirklich auf andere Weise teilen möchten, können Sie FacetGrid verwenden, indem Sie die Funktion auf der Achsenseite anstelle der Funktion auf der Bildseite angeben.
fmri = sns.load_dataset("fmri")
g=sns.FacetGrid(fmri,col='event')
g.map_dataframe(sns.lineplot,data=fmri,x='timepoint',y='signal',hue="region")
[Main-2] Hist, Ked, Ecdf und Teppich von Displot
[Main-2.1] Standardhist
Der Standardwert ist kind = 'hist'
penguin = sns.load_dataset("penguins")
sns.displot(data=penguin,x='bill_depth_mm')
#sns.displot(data=penguin,x='bill_depth_mm',kind='hist')
Sie können die Ausdrucksmethode mit dem Argumentelement ändern Der Standardwert ist bar
sns.displot(data=penguin,x='bill_depth_mm',kind='hist',element='poly')
sns.displot(data=penguin,x='bill_depth_mm',kind='hist',element='step')
poly
step
Sie können auch die Feinheit der Division durch Bins ändern
sns.displot(data=penguin,x='bill_depth_mm',kind='hist',element='poly',bins=100)
[Main-2.2] Fügen Sie dem Histgramm kde (Kernel-Dichteschätzung) hinzu
sns.displot(data=penguin,x='bill_depth_mm',kind='hist',kde=True)
Wenn Sie kind = 'kde' angeben, verschwindet hist natürlich.
sns.displot(data=penguin,x='bill_depth_mm',kind='kde')
[Main-2.2] Versuchen Sie, mit den ursprünglichen Funktionen von hist und kde zu zeichnen
sns.histplot(data=penguin,x='bill_depth_mm')
sns.kdeplot(data=penguin,x='bill_depth_mm')
[Main-2.3] Überprüfen Sie die Bewegung von kde
Bw_adjust, um zu entscheiden, wie viel Datenbreite beim Glätten berücksichtigt werden soll
sns.displot(data=penguin,x='bill_depth_mm',kind='kde',bw_adjust=.2)
Wenn 0,2
Wenn 100
[Main-2.4] Ändern Sie die Farbe auf einer anderen Achse
Wie gewöhnlich Farbcodierung nach Farbton Bildschirmteilung nach Spalte
sns.displot(data=penguin,x='bill_depth_mm',kind='kde',hue='sex',col='island')
[Main-2.5] Erstellen Sie ein gestapeltes Diagramm
Geben Sie den Stapel an, wenn Sie Dichtefunktionen stapeln möchten Achten Sie darauf, nicht zu missverstehen, dass mehr Leute an der Seite sind, da Sie nur oben sind
Kann mit hist oder kde verwendet werden
sns.displot(data=penguin,x='bill_depth_mm',kind='kde',hue='sex',col='island',multiple="stack")
Geben Sie linewidth = 0 an, wenn Sie die Grenzfläche beim Stapeln löschen möchten
sns.displot(data=penguin,x='bill_depth_mm',kind='kde',hue='sex',col='island',multiple="stack",linewidth=0)
Wenn Sie außerdem die Kantenfarbe = "0,1" angeben, können Sie die Grenzlinie verstärken.
Setzen Sie die Füllung auf Falsch, wenn Sie die Farbe im gestapelten Diagramm entfernen möchten Es wird endlich zu einer Grafik, die missverstanden zu werden scheint
sns.displot(data=penguin,x='bill_depth_mm',kind='kde',hue='sex',multiple="stack",fill=False)
[Main-2.6] Über Alpha, nicht stapeln, Wasserzeichen hinzufügen
Sie können die Farbe durch Anpassen von Alpha anpassen
sns.displot(data=penguin,x='bill_depth_mm',kind='kde',hue='sex',fill=True,alpha=0.5)
[Main-2.7] Über mehrere, als Flächenverhältnis ausdrücken, abdecken, seitlich legen
Durch Angabe von Füllung anstelle von Stapel kann dargestellt werden, welches Verhältnis in dem Bereich, in dem das Ganze 1 ist, größer ist.
sns.displot(data=penguin,x='bill_depth_mm',kind='kde',hue='sex',multiple="fill")
Siehe die Änderungen mit hist
sns.displot(data=penguin,x='bill_depth_mm',kind='hist',hue='sex',fill=True,multiple="fill")
sns.displot(data=penguin,x='bill_depth_mm',kind='hist',hue='sex',fill=True,multiple="layer")
sns.displot(data=penguin,x='bill_depth_mm',kind='hist',hue='sex',fill=True,multiple="dodge")
sns.displot(data=penguin,x='bill_depth_mm',kind='hist',hue='sex',fill=True,multiple="stack")
fill
layer
dodge
stack
[Main-2.8] Plot in 2 Dimensionen
Sowohl hist als auch kde können durch Angabe von x und y zu einem zweidimensionalen Diagramm gemacht werden. Als Bild die Konturlinien der Karte
sns.displot(data=penguin, x="flipper_length_mm", y="bill_length_mm",kind='hist')
sns.displot(data=penguin, x="flipper_length_mm", y="bill_length_mm",kind='kde')
Farbcodierung ist Farbton Füllen ist Füllen Bildschirmteilung ist col Es gibt keine Änderung in der Regel
[Main-2.9] Zweidimensionale Farbabstufung
Wenn Sie eine Farbabstufung hinzufügen möchten, geben Sie das Muster in cmap an
Füllt nicht bewertete Bereiche aus (geringe Wahrscheinlichkeit) Schwelle = 0 (positiver Wert kleiner als 1) Passen Sie die Feinheit der Abstufungsstufe mit den angegebenen Werten an
sns.displot(data=penguin, x="flipper_length_mm", y="bill_length_mm", kind="kde",fill=True, thresh=0, levels=10, cmap='cubehelix')
thresh=0, levels=10
thresh=0.8, levels=10
thresh=0, levels=100
[Main-2.10] Was ist Teppichplot?
Ein Teppich ist wie ein feiner Schnurrbart an der Seite des Schafts. Sie können überprüfen, wie dicht der Teppich ist, indem Sie die Dichte mit kde betrachten
sns.displot(data=penguin, x="flipper_length_mm", y="bill_length_mm", kind="kde", rug=True)
Kann mit einem Streudiagramm kombiniert werden
sns.scatterplot(data=penguin, x="flipper_length_mm", y="bill_length_mm")
sns.rugplot(data=penguin, x="flipper_length_mm", y="bill_length_mm")
[Main-2.11] Seitwärts zeichnen
Das Histgramm ist ein Bild eines gestapelten Graphen mit Werten auf der x-Achse. Durch Angabe eines Werts für y wird automatisch horizontal gezeichnet
sns.displot(data=penguin,y='bill_depth_mm',kind='kde',hue='sex',col='island')
[Main-2.12] Angeben eines kleinen Titels für die Handlung
Ich habe zum Zeitpunkt der Option über den gesamten Titel gesprochen Um jeden kleinen Titel zu ändern, ist es auch möglich, Diagramminformationen einmal in g einzufügen und von col_name abzurufen (Siehe set_titles für Details)
g=sns.displot(data=penguin,y='bill_depth_mm',kind='kde',hue='sex',col='island')
g.set_titles("{col_name} penguins")
[Main-2.13] ecdf kumulative Darstellung
Kann als kumulative Wahrscheinlichkeit ausgegeben werden
sns.displot(data=penguin, x="flipper_length_mm", kind="ecdf")
sns.displot(data=penguin, x="flipper_length_mm", kind="ecdf",complementary=True)
complementary=True
Kann für die Überlebenszeitanalyse usw. verwendet werden.
[Main-2.14] col_wrap, das den Zeichenbildschirm in mehrere Teile unterteilt, und log_scale, das die logarithmische Verarbeitung ausführt
Displot verfügt auch über eine Funktion, mit der Sie festlegen können, ob die Protokollverarbeitung intern durchgeführt werden soll. Es ist auch möglich, eine logarithmische Verarbeitung nur auf einer Achse durchzuführen
Das Zeichnen erfolgt normalerweise mit col und es wird natürlich geteilt, 〇 Sie können auch angeben, dass Sie in Spalten anzeigen möchten
diamonds = sns.load_dataset("diamonds")
sns.displot(data=diamonds, x="depth", y="price", log_scale=(True, False), col="clarity",col_wrap=5,kind='kde')
[Main-3] Streifen, Schwarm, Box.box, Violine, Point, Bar, Boxen, nach Catplot zählen
[Main-3.1] Standard des Catplots
Normalerweise für Streifen angegeben
Da es sich um ein für Kategorien geeignetes Visualisierungswerkzeug handelt, entspricht es qualitativen Variablen
sns.catplot(data=penguin,x='species',y='bill_depth_mm',height=6,kind='strip')
Schauen wir uns die Arten an
sns.catplot(data=penguin,x='species',y='bill_depth_mm',height=6,kind='box')
sns.catplot(data=penguin,x='species',y='bill_depth_mm',height=6,kind='boxen')
sns.catplot(data=penguin,x='species',height=6,kind='count')
sns.catplot(data=penguin,x='species',y='bill_depth_mm',height=6,kind='bar')
sns.catplot(data=penguin,x='species',y='bill_depth_mm',height=6,kind='violin')
sns.catplot(data=penguin,x='species',y='bill_depth_mm',height=6,kind='swarm')
sns.catplot(data=penguin,x='species',y='bill_depth_mm',height=6,kind='point')
box
boxen
count
Balken (siehe y-Achse der Zählung)
violin
swarm
point Kann für Gruppenvergleiche, Dispersionsanalysen usw. verwendet werden.
Ich denke, dass Sie das Obige sehen und verstehen können, dass es einen Vertrauensbereich gibt Kann mit ci eingestellt werden
[Main-3.2] Ausdruck von Box und Violine
Ob in derselben Spalte oder in einem separaten Ausweichen gezeichnet werden soll
sns.catplot(data=penguin, kind="box",x="species", y="body_mass_g", hue="sex", dodge=False,height=6)
sns.catplot(data=penguin, kind="box",x="species", y="body_mass_g", hue="sex", dodge=True,height=6)
Gleiches gilt für Schwarm und Geige
Wenn Sie in der Leiste Ausweichen auf Falsch setzen, ist dies eine verwirrende Zahl
Ich fahre nicht wirklich, ich verstecke mich dahinter
Split kann für Violine ausgewählt werden
sns.catplot(data=penguin, kind="violin",x="species", y="body_mass_g", hue="sex", split=True)
Sie können y und x tauschen, um es seitwärts zu drehen
sns.catplot(data=penguin, kind="violin",y="species", x="body_mass_g", hue="sex", split=True)
[Main-3.3] Schwarm und Box und Geige
Schwarm neigt dazu, viele Punkte zu haben Wenn es nicht gezeichnet werden kann, wird gewarnt, dass der Punkt, der gezeichnet werden soll, nicht erstellt wird. Einfach
Es gibt auch eine Funktion, die es überlagert, indem es nach der Box oder Geige hinzugefügt wird.
sns.catplot(data=penguin, kind="box",x="species", y="body_mass_g",height=6)
sns.swarmplot(data=penguin,x="species", y="body_mass_g",hue='sex',palette="Set1")
[Adv] Erweiterte Verwendung
【adv-1】pair plot
Verwenden Sie ein praktisches Paar, um den gesamten Datenrahmen aus der Vogelperspektive zu betrachten
Wenn Sie die Pairplot-Funktion aufrufen, ist dies eine bekannte Zahl.
penguin = sns.load_dataset("penguins")
sns.pairplot(penguin)
sns.pairplot(penguin, hue="species)
Mit PairGrid können Sie das obere und untere Plotformat erneut angeben.
penguin = sns.load_dataset("penguins")
g = sns.PairGrid(penguin, diag_sharey=False)
g.map_upper(sns.scatterplot, s=15)
g.map_lower(sns.kdeplot)
g.map_diag(sns.kdeplot, lw=2)
【adv-2】heat map
Gibt die Heatmap für Daten im Matrixformat zurück
flights = sns.load_dataset("flights")
flights = flights.pivot("month","year", "passengers")
sns.heatmap(flights)
Wenn Sie die Zahl zusammenstellen möchten, setzen Sie annot auf True und verwenden Sie fmt, damit die Zahl nicht wild wird.
sns.heatmap(flights, annot=True, fmt="d")
Wenn Sie eine Grenze schreiben möchten, geben Sie diese mit Linienbreiten an
sns.heatmap(flights, linewidths=.5)
Mit triu_indices_from, das eine numpy Dreiecksmatrix erstellt, Indem Sie eine Matrix wie die von T, F 1,0 in die Maske einfügen, Kann geformt und ausgegeben werden
corr = np.corrcoef(np.random.randn(10, 200))
mask = np.zeros_like(corr)
mask[np.triu_indices_from(mask)] = True
with sns.axes_style("white"):
f, ax = plt.subplots(figsize=(7, 5))
ax = sns.heatmap(corr, mask=mask, vmax=.3, square=True)
【adv-3】joint plot
Überprüfen Sie die Verteilung jeder Variablen, während Sie die Beziehung zwischen den beiden Variablen als Dichte betrachten.
sns.jointplot(x='bill_length_mm', y='bill_depth_mm', data=penguin)
Dies hat auch einen Typ und kann nach Art angegeben werden Die obige Standardeinstellung ist Streuung
kde
hist
hex
reg(regression)
Resid-Modellplot zur Überprüfung von Residuen (später beschrieben)
Sie können auch mit Jointgrid zeichnen, während Sie über Kombinationen nachdenken
Geben Sie die Haupt- und Seitenansicht beliebig an
g=sns.JointGrid(x='bill_length_mm', y='bill_depth_mm', data=penguin)
g.plot(sns.regplot, sns.kdeplot)
Teppich hinzufügen, kde zum Streudiagramm hinzufügen usw. Fügen Sie mit plot_joint und marginals hinzu
g = sns.jointplot(data=penguin, x="bill_length_mm", y="bill_depth_mm")
g.plot_joint(sns.kdeplot, color="r", zorder=0, levels=6)
g.plot_marginals(sns.rugplot, color="r", height=-.15, clip_on=False)
Erstellen Sie eine beliebige Kombination, indem Sie main, top, right angeben
g = sns.JointGrid()
x, y = penguin["bill_length_mm"], penguin["bill_depth_mm"]
sns.scatterplot(x=x, y=y, ec="b", fc="none", s=100, linewidth=1.5, ax=g.ax_joint)
sns.histplot(x=x, fill=False, linewidth=2, ax=g.ax_marg_x)
sns.kdeplot(y=y, linewidth=2, ax=g.ax_marg_y)
【adv-4】linear model plot
Anscheinend sieht die Kombination aus Facette und Regplot wie lmplot aus, also werde ich es im Grunde mit lmplot erklären. Es scheint Regplot zu sein, dass es mit Pairplot und Jointplot funktioniert
Visualisieren Sie die lineare Regression
sns.lmplot(x='bill_length_mm', y='body_mass_g', data=penguin)
Farbcodierung nach Farbton
Bestimmen Sie die Reihenfolge der Polypoly-Regression mit der Reihenfolge
sns.lmplot(x='bill_length_mm', y='body_mass_g', data=penguin, order=5)
Es gibt auch eine Option zur Logistik
penguin['male'] = pd.get_dummies(penguin.sex)['Male']
sns.lmplot(x='bill_length_mm', y='male',data=penguin, logistic=True)
Nachdem ich ein Modell erstellt habe, möchte ich die Residuen vergleichen Es wird eine Restprüfung durchgeführt, um festzustellen, inwieweit das gezeichnete lm-Modell (linear oder polypoly) die Daten erklären kann. Als Beurteilung des linearen Modells kann das Modell bis zu einem gewissen Grad als gutes Modell beurteilt werden, wenn der Rest der Normalverteilung zu folgen scheint.
Wahrscheinlich wegen der Beziehung zwischen reg und lm Läuft die Hintergrundfunktion auf "Resid" des Jointplot-Residplots?
sns.jointplot(x='bill_length_mm', y='body_mass_g', data=penguin,order=1,kind='resid')
sns.jointplot(x='bill_length_mm', y='body_mass_g', data=penguin,order=10,kind='resid')
Rest erster Ordnung
Rest 10. Ordnung
Vergleichen Sie mit dem Modell von sklearn
import sklearn
from sklearn import datasets,linear_model
penguin=penguin.dropna(how='any')
model = linear_model.LinearRegression()
X = np.array(penguin["bill_length_mm"]).reshape(-1, 1)
Y = np.array(penguin["body_mass_g"]).reshape(-1, 1)
model.fit(X, Y)
pred_y = model.predict(X)
plt.scatter(x=X, y=Y-pred_y)
Es scheint, dass er den Rest berechnen wird.
【adv-5】clustermap
iris = sns.load_dataset("iris")
species = iris.pop("species")
g = sns.clustermap(iris)
Visualisiert hierarchisches Clustering Geben Sie nach Methode an, welche Entfernungskriterien gruppiert werden sollen
Dieser Bereich ist schwer zu erklären, daher ist es schneller, wenn Sie hierarchisches Clustering lernen. Die Methode wird aus der Scipy-Berechnung scipy.cluster.hierarchy.linkage ermittelt .verknüpfung )
mathod
single
complete
average
weighted
centroid
median
ward
single
Schließlich
Wir planen, weitere Visualisierungsmethoden einzuführen Selbst wenn der Code schmutzig ist, möchte ich vorsichtig sein, wenn ich so oft wie möglich die falsche Zahl verwende
Referenz
Release news-v0.11.0 (September 2020)