Seaborn - Guida rapida
Nel mondo di Analytics, il modo migliore per ottenere informazioni dettagliate è visualizzare i dati. I dati possono essere visualizzati rappresentandoli come trame facili da capire, esplorare e comprendere. Tali dati aiutano ad attirare l'attenzione degli elementi chiave.
Per analizzare un set di dati utilizzando Python, utilizziamo Matplotlib, una libreria di plottaggio 2D ampiamente implementata. Allo stesso modo, Seaborn è una libreria di visualizzazione in Python. È costruito sopra Matplotlib.
Seaborn Vs Matplotlib
Si riassume che se Matplotlib "cerca di rendere le cose facili facili e quelle difficili possibili", Seaborn cerca di rendere facili anche un insieme ben definito di cose difficili.
Seaborn aiuta a risolvere i due principali problemi affrontati da Matplotlib; i problemi sono -
- Parametri Matplotlib predefiniti
- Lavorare con i frame di dati
Poiché Seaborn si complimenta e amplia Matplotlib, la curva di apprendimento è abbastanza graduale. Se conosci Matplotlib, sei già a metà di Seaborn.
Caratteristiche importanti di Seaborn
Seaborn è basato sulla libreria di visualizzazione principale di Python Matplotlib. È pensato per servire come complemento e non come sostituto. Tuttavia, Seaborn ha alcune caratteristiche molto importanti. Vediamone alcuni qui. Le funzionalità aiutano in -
- Temi integrati per lo styling della grafica matplotlib
- Visualizzazione di dati univariati e bivariati
- Adattamento e visualizzazione di modelli di regressione lineare
- Rappresentazione grafica di dati di serie temporali statistiche
- Seaborn funziona bene con le strutture dati NumPy e Pandas
- Viene fornito con temi incorporati per lo styling della grafica Matplotlib
Nella maggior parte dei casi, utilizzerai comunque Matplotlib per la stampa semplice. Si consiglia la conoscenza di Matplotlib per modificare i grafici predefiniti di Seaborn.
In questo capitolo, discuteremo la configurazione dell'ambiente per Seaborn. Cominciamo con l'installazione e capiamo come iniziare man mano che procediamo.
Installazione di Seaborn e avvio
In questa sezione, comprenderemo i passaggi coinvolti nell'installazione di Seaborn.
Utilizzando Pip Installer
Per installare l'ultima versione di Seaborn, puoi usare pip -
pip install seaborn
Per Windows, Linux e Mac utilizzando Anaconda
Anaconda (da https://www.anaconda.com/è una distribuzione Python gratuita per lo stack SciPy. È disponibile anche per Linux e Mac.
È anche possibile installare la versione rilasciata utilizzando conda -
conda install seaborn
Per installare la versione di sviluppo di Seaborn direttamente da GitHub
https://github.com/mwaskom/seaborn"
Dipendenze
Considera le seguenti dipendenze di Seaborn:
- Python 2.7 o 3.4+
- numpy
- scipy
- pandas
- matplotlib
In questo capitolo, discuteremo come importare dataset e librerie. Cominciamo col capire come importare le librerie.
Importazione di librerie
Cominciamo importando Pandas, che è un'ottima libreria per la gestione di set di dati relazionali (in formato tabella). Seaborn è utile quando si ha a che fare con DataFrame, la struttura dati più utilizzata per l'analisi dei dati.
Il seguente comando ti aiuterà a importare i Panda:
# Pandas for managing datasets
import pandas as pd
Ora, importiamo la libreria Matplotlib, che ci aiuta a personalizzare i nostri grafici.
# Matplotlib for additional customization
from matplotlib import pyplot as plt
Importeremo la libreria Seaborn con il seguente comando:
# Seaborn for plotting and styling
import seaborn as sb
Importazione di set di dati
Abbiamo importato le librerie richieste. In questa sezione, capiremo come importare i set di dati richiesti.
Seaborn viene fornito con alcuni importanti set di dati nella libreria. Quando Seaborn è installato, i set di dati vengono scaricati automaticamente.
Puoi utilizzare uno qualsiasi di questi set di dati per il tuo apprendimento. Con l'aiuto della seguente funzione è possibile caricare il set di dati richiesto
load_dataset()
Importazione dei dati come Pandas DataFrame
In questa sezione, importeremo un set di dati. Questo set di dati viene caricato come Pandas DataFrame per impostazione predefinita. Se è presente una funzione in Pandas DataFrame, funziona su questo DataFrame.
La seguente riga di codice ti aiuterà a importare il set di dati:
# Seaborn for plotting and styling
import seaborn as sb
df = sb.load_dataset('tips')
print df.head()
La riga di codice precedente genererà il seguente output:
total_bill tip sex smoker day time size
0 16.99 1.01 Female No Sun Dinner 2
1 10.34 1.66 Male No Sun Dinner 3
2 21.01 3.50 Male No Sun Dinner 3
3 23.68 3.31 Male No Sun Dinner 2
4 24.59 3.61 Female No Sun Dinner 4
Per visualizzare tutti i set di dati disponibili nella libreria Seaborn, è possibile utilizzare il seguente comando con il get_dataset_names() funziona come mostrato di seguito -
import seaborn as sb
print sb.get_dataset_names()
La riga di codice precedente restituirà l'elenco dei set di dati disponibili come output seguente
[u'anscombe', u'attention', u'brain_networks', u'car_crashes', u'dots',
u'exercise', u'flights', u'fmri', u'gammas', u'iris', u'planets', u'tips',
u'titanic']
DataFramesmemorizzare i dati sotto forma di griglie rettangolari con cui i dati possono essere visualizzati facilmente. Ogni riga della griglia rettangolare contiene i valori di un'istanza e ogni colonna della griglia è un vettore che contiene i dati per una variabile specifica. Ciò significa che non è necessario che le righe di un DataFrame contengano valori dello stesso tipo di dati, possono essere numerici, di carattere, logici, ecc. I DataFrame per Python sono forniti con la libreria Pandas e sono definiti come strutture di dati con etichetta bidimensionale con tipi di colonne potenzialmente diversi.
Per maggiori dettagli su DataFrames, visita il nostro tutorial sui panda.
La visualizzazione dei dati è un passo e rendere i dati visualizzati più piacevoli è un altro passo. La visualizzazione gioca un ruolo fondamentale nel comunicare intuizioni quantitative a un pubblico per catturare la sua attenzione.
Estetica significa un insieme di principi che riguardano la natura e l'apprezzamento della bellezza, specialmente nell'arte. La visualizzazione è un'arte di rappresentare i dati in modo efficace e più semplice possibile.
La libreria Matplotlib supporta fortemente la personalizzazione, ma sapere quali impostazioni modificare per ottenere una trama attraente e anticipata è ciò di cui si dovrebbe essere consapevoli per utilizzarla. A differenza di Matplotlib, Seaborn è ricco di temi personalizzati e un'interfaccia di alto livello per personalizzare e controllare l'aspetto delle figure Matplotlib.
Esempio
import numpy as np
from matplotlib import pyplot as plt
def sinplot(flip = 1):
x = np.linspace(0, 14, 100)
for i in range(1, 5):
plt.plot(x, np.sin(x + i * .5) * (7 - i) * flip)
sinplot()
plt.show()
Ecco come appare una trama con i valori predefiniti Matplotlib -
Per modificare lo stesso grafico con le impostazioni predefinite di Seaborn, utilizzare il file set() funzione -
Esempio
import numpy as np
from matplotlib import pyplot as plt
def sinplot(flip = 1):
x = np.linspace(0, 14, 100)
for i in range(1, 5):
plt.plot(x, np.sin(x + i * .5) * (7 - i) * flip)
import seaborn as sb
sb.set()
sinplot()
plt.show()
Produzione
Le due figure precedenti mostrano la differenza nei grafici Matplotlib e Seaborn predefiniti. La rappresentazione dei dati è la stessa, ma lo stile di rappresentazione varia in entrambe.
Fondamentalmente, Seaborn divide i parametri Matplotlib in due gruppi:
- Stili di trama
- Scala del grafico
Stili di figura di Seaborn
L'interfaccia per manipolare gli stili è set_style(). Usando questa funzione puoi impostare il tema della trama. Secondo l'ultima versione aggiornata, di seguito sono riportati i cinque temi disponibili.
- Darkgrid
- Whitegrid
- Dark
- White
- Ticks
Proviamo ad applicare un tema dall'elenco sopra menzionato. Il tema predefinito della trama saràdarkgrid che abbiamo visto nell'esempio precedente.
Esempio
import numpy as np
from matplotlib import pyplot as plt
def sinplot(flip=1):
x = np.linspace(0, 14, 100)
for i in range(1, 5):
plt.plot(x, np.sin(x + i * .5) * (7 - i) * flip)
import seaborn as sb
sb.set_style("whitegrid")
sinplot()
plt.show()
Produzione
La differenza tra i due grafici precedenti è il colore di sfondo
Rimozione delle spine degli assi
Nei temi bianco e zecche, possiamo rimuovere le spine dell'asse superiore e destro usando il despine() funzione.
Esempio
import numpy as np
from matplotlib import pyplot as plt
def sinplot(flip=1):
x = np.linspace(0, 14, 100)
for i in range(1, 5):
plt.plot(x, np.sin(x + i * .5) * (7 - i) * flip)
import seaborn as sb
sb.set_style("white")
sinplot()
sb.despine()
plt.show()
Produzione
Nei grafici regolari, usiamo solo gli assi sinistro e inferiore. Usando ildespine() , possiamo evitare le spine dorsali degli assi destro e superiore non necessarie, che non sono supportate in Matplotlib.
Ignorare gli elementi
Se vuoi personalizzare gli stili Seaborn, puoi passare un dizionario di parametri al file set_style() funzione. I parametri disponibili vengono visualizzati utilizzandoaxes_style() funzione.
Esempio
import seaborn as sb
print sb.axes_style
Produzione
{'axes.axisbelow' : False,
'axes.edgecolor' : 'white',
'axes.facecolor' : '#EAEAF2',
'axes.grid' : True,
'axes.labelcolor' : '.15',
'axes.linewidth' : 0.0,
'figure.facecolor' : 'white',
'font.family' : [u'sans-serif'],
'font.sans-serif' : [u'Arial', u'Liberation
Sans', u'Bitstream Vera Sans', u'sans-serif'],
'grid.color' : 'white',
'grid.linestyle' : u'-',
'image.cmap' : u'Greys',
'legend.frameon' : False,
'legend.numpoints' : 1,
'legend.scatterpoints': 1,
'lines.solid_capstyle': u'round',
'text.color' : '.15',
'xtick.color' : '.15',
'xtick.direction' : u'out',
'xtick.major.size' : 0.0,
'xtick.minor.size' : 0.0,
'ytick.color' : '.15',
'ytick.direction' : u'out',
'ytick.major.size' : 0.0,
'ytick.minor.size' : 0.0}
La modifica dei valori di uno qualsiasi dei parametri altererà lo stile di stampa.
Esempio
import numpy as np
from matplotlib import pyplot as plt
def sinplot(flip=1):
x = np.linspace(0, 14, 100)
for i in range(1, 5):
plt.plot(x, np.sin(x + i * .5) * (7 - i) * flip)
import seaborn as sb
sb.set_style("darkgrid", {'axes.axisbelow': False})
sinplot()
sb.despine()
plt.show()
Produzione
Scalare gli elementi del grafico
Abbiamo anche il controllo sugli elementi della trama e possiamo controllare la scala della trama utilizzando il set_context()funzione. Abbiamo quattro modelli preimpostati per i contesti, in base alla dimensione relativa, i contesti sono denominati come segue
- Paper
- Notebook
- Talk
- Poster
Per impostazione predefinita, il contesto è impostato su notebook; ed è stato utilizzato nelle trame sopra.
Esempio
import numpy as np
from matplotlib import pyplot as plt
def sinplot(flip = 1):
x = np.linspace(0, 14, 100)
for i in range(1, 5):
plt.plot(x, np.sin(x + i * .5) * (7 - i) * flip)
import seaborn as sb
sb.set_style("darkgrid", {'axes.axisbelow': False})
sinplot()
sb.despine()
plt.show()
Produzione
La dimensione dell'output del grafico effettivo è di dimensioni maggiori rispetto ai grafici precedenti.
Note - A causa del ridimensionamento delle immagini sulla nostra pagina Web, potresti perdere la differenza effettiva nei nostri grafici di esempio.
Il colore gioca un ruolo importante rispetto a qualsiasi altro aspetto nelle visualizzazioni. Se usato in modo efficace, il colore aggiunge più valore alla trama. Una tavolozza indica una superficie piana su cui un pittore dispone e mescola i colori.
Tavolozza dei colori di costruzione
Seaborn fornisce una funzione chiamata color_palette(), che può essere utilizzato per dare colori alle trame e aggiungervi più valore estetico.
Utilizzo
seaborn.color_palette(palette = None, n_colors = None, desat = None)
Parametro
La tabella seguente elenca i parametri per la creazione della tavolozza dei colori:
Sr.No. | Palatte e descrizione |
---|---|
1 | n_colors Numero di colori nella tavolozza. Se è Nessuno, il valore predefinito dipenderà da come viene specificata la tavolozza. Per impostazione predefinita il valore din_colors è di 6 colori. |
2 | desat Proporzione per desaturare ogni colore. |
Ritorno
Return si riferisce all'elenco delle tuple RGB. Di seguito sono riportate le tavolozze Seaborn prontamente disponibili:
- Deep
- Muted
- Bright
- Pastel
- Dark
- Colorblind
Oltre a questi, si può anche generare una nuova tavolozza
È difficile decidere quale tavolozza deve essere utilizzata per un dato set di dati senza conoscere le caratteristiche dei dati. Consapevoli di ciò, classificheremo i diversi modi di utilizzocolor_palette() tipi -
- qualitative
- sequential
- diverging
Abbiamo un'altra funzione seaborn.palplot()che si occupa di tavolozze di colori. Questa funzione traccia la tavolozza dei colori come una matrice orizzontale. Ne sapremo di più in meritoseaborn.palplot() nei prossimi esempi.
Tavolozze di colori qualitative
Le tavolozze qualitative o categoriali sono le più adatte per tracciare i dati categoriali.
Esempio
from matplotlib import pyplot as plt
import seaborn as sb
current_palette = sb.color_palette()
sb.palplot(current_palette)
plt.show()
Produzione
Non abbiamo passato alcun parametro in color_palette();per impostazione predefinita, vediamo 6 colori. Puoi vedere il numero di colori desiderato passando un valore al filen_colorsparametro. Qui, ilpalplot() viene utilizzato per tracciare la matrice di colori orizzontalmente.
Tavolozze di colori sequenziali
I grafici sequenziali sono adatti per esprimere la distribuzione dei dati che vanno da valori relativi inferiori a valori più alti all'interno di un intervallo.
Aggiungendo un carattere aggiuntivo "s" al colore passato al parametro color verrà tracciato il grafico sequenziale.
Esempio
from matplotlib import pyplot as plt
import seaborn as sb
current_palette = sb.color_palette()
sb.palplot(sb.color_palette("Greens"))
plt.show()
Note −Dobbiamo aggiungere "s" al parametro come "Verdi" nell'esempio precedente.
Tavolozza dei colori divergenti
Le tavolozze divergenti utilizzano due colori diversi. Ogni colore rappresenta la variazione del valore che va da un punto comune in entrambe le direzioni.
Si supponga di tracciare i dati compresi tra -1 e 1. I valori da -1 a 0 richiedono un colore e da 0 a +1 un altro colore.
Per impostazione predefinita, i valori sono centrati da zero. Puoi controllarlo con il centro parametro passando un valore.
Esempio
from matplotlib import pyplot as plt
import seaborn as sb
current_palette = sb.color_palette()
sb.palplot(sb.color_palette("BrBG", 7))
plt.show()
Produzione
Impostazione della tavolozza dei colori predefinita
Le funzioni color_palette() ha un compagno chiamato set_palette()La relazione tra loro è simile alle coppie trattate nel capitolo sull'estetica. Gli argomenti sono gli stessi per entrambiset_palette() e color_palette(), ma i parametri Matplotlib predefiniti vengono modificati in modo che la tavolozza venga utilizzata per tutti i grafici.
Esempio
import numpy as np
from matplotlib import pyplot as plt
def sinplot(flip = 1):
x = np.linspace(0, 14, 100)
for i in range(1, 5):
plt.plot(x, np.sin(x + i * .5) * (7 - i) * flip)
import seaborn as sb
sb.set_style("white")
sb.set_palette("husl")
sinplot()
plt.show()
Produzione
Tracciare la distribuzione univariata
La distribuzione dei dati è la cosa più importante che dobbiamo capire durante l'analisi dei dati. Qui vedremo come seaborn ci aiuta a comprendere la distribuzione univariata dei dati.
Funzione distplot()fornisce il modo più conveniente per dare una rapida occhiata alla distribuzione univariata. Questa funzione traccia un istogramma che si adatta alla stima della densità del kernel dei dati.
Utilizzo
seaborn.distplot()
Parametri
La tabella seguente elenca i parametri e la loro descrizione:
Sr.No. | Parametro e descrizione |
---|---|
1 | data Serie, matrice 1d o elenco |
2 | bins Specifica dei contenitori storici |
3 | hist bool |
4 | kde bool |
Questi sono parametri fondamentali e importanti da esaminare.
Gli istogrammi rappresentano la distribuzione dei dati formando contenitori lungo l'intervallo dei dati e quindi disegnando barre per mostrare il numero di osservazioni che rientrano in ogni contenitore.
Seaborn viene fornito con alcuni set di dati e ne abbiamo utilizzati pochi nei capitoli precedenti. Abbiamo imparato come caricare il set di dati e come cercare l'elenco dei set di dati disponibili.
Seaborn viene fornito con alcuni set di dati e ne abbiamo utilizzati pochi nei capitoli precedenti. Abbiamo imparato come caricare il set di dati e come cercare l'elenco dei set di dati disponibili.
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.distplot(df['petal_length'],kde = False)
plt.show()
Produzione
Qui, kdeflag è impostato su False. Di conseguenza, la rappresentazione del grafico di stima del kernel verrà rimossa e verrà tracciato solo l'istogramma.
Kernel Density Estimation (KDE) è un modo per stimare la funzione di densità di probabilità di una variabile casuale continua. Viene utilizzato per analisi non parametriche.
L'impostazione di hist flag su False in distplot produrrà il grafico di stima della densità del kernel.
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.distplot(df['petal_length'],hist=False)
plt.show()
Produzione
Adattamento della distribuzione parametrica
distplot() viene utilizzato per visualizzare la distribuzione parametrica di un set di dati.
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.distplot(df['petal_length'])
plt.show()
Produzione
Tracciare la distribuzione bivariata
La distribuzione bivariata viene utilizzata per determinare la relazione tra due variabili. Si occupa principalmente della relazione tra due variabili e di come si comporta una variabile rispetto all'altra.
Il modo migliore per analizzare la distribuzione bivariata in seaborn è usare il jointplot() funzione.
Jointplot crea una figura multi-pannello che proietta la relazione bivariata tra due variabili e anche la distribuzione univariata di ciascuna variabile su assi separati.
Grafico a dispersione
Il grafico a dispersione è il modo più conveniente per visualizzare la distribuzione in cui ogni osservazione è rappresentata in un grafico bidimensionale tramite gli assi xey.
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.jointplot(x = 'petal_length',y = 'petal_width',data = df)
plt.show()
Produzione
La figura sopra mostra la relazione tra petal_length e petal_widthnei dati Iris. Una tendenza nella trama dice che esiste una correlazione positiva tra le variabili in studio.
Hexbin Plot
Il binning esagonale viene utilizzato nell'analisi dei dati bivariati quando la densità dei dati è scarsa, ovvero quando i dati sono molto dispersi e difficili da analizzare tramite grafici a dispersione.
Un parametro aggiuntivo chiamato "tipo" e valore "esadecimale" traccia il grafico hexbin.
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.jointplot(x = 'petal_length',y = 'petal_width',data = df,kind = 'hex')
plt.show()
Stima della densità del kernel
La stima della densità del kernel è un modo non parametrico per stimare la distribuzione di una variabile. In seaborn, possiamo tracciare un kde usandojointplot().
Passa il valore 'kde' al tipo di parametro per tracciare la trama del kernel.
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.jointplot(x = 'petal_length',y = 'petal_width',data = df,kind = 'hex')
plt.show()
Produzione
I set di dati oggetto di studio in tempo reale contengono molte variabili. In questi casi, dovrebbe essere analizzata la relazione tra ogni variabile. Tracciare la distribuzione bivariata per (n, 2) combinazioni sarà un processo molto complesso e richiederà tempo.
Per tracciare più distribuzioni bivariate a coppie in un set di dati, è possibile utilizzare il pairplot()funzione. Questo mostra la relazione per la combinazione (n, 2) di variabili in un DataFrame come matrice di grafici e i grafici diagonali sono i grafici univariati.
Assi
In questa sezione impareremo cosa sono gli assi, il loro utilizzo, i parametri e così via.
Utilizzo
seaborn.pairplot(data,…)
Parametri
La tabella seguente elenca i parametri per gli assi:
Sr.No. | Parametro e descrizione |
---|---|
1 | data Dataframe |
2 | hue Variabile nei dati per mappare gli aspetti del grafico a colori diversi. |
3 | palette Set di colori per mappare la variabile di tonalità |
4 | kind Tipo di trama per le relazioni di non identità. {'scatter', 'reg'} |
5 | diag_kind Tipo di trama per le sottotrame diagonali. {'hist', 'kde'} |
Tutti gli altri parametri, tranne i dati, sono facoltativi. Ci sono pochi altri parametri chepairplotpuò accettare. I parametri sopra menzionati sono spesso usati.
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.set_style("ticks")
sb.pairplot(df,hue = 'species',diag_kind = "kde",kind = "scatter",palette = "husl")
plt.show()
Produzione
Possiamo osservare le variazioni in ogni trama. I grafici sono in formato matrice in cui il nome della riga rappresenta l'asse x e il nome della colonna rappresenta l'asse y.
I grafici diagonali sono grafici della densità del kernel in cui gli altri grafici sono grafici a dispersione come menzionato.
Nei nostri capitoli precedenti abbiamo appreso dei grafici a dispersione, dei grafici hexbin e dei grafici kde che vengono utilizzati per analizzare le variabili continue oggetto di studio. Questi grafici non sono adatti quando la variabile in esame è categoriale.
Quando una o entrambe le variabili in esame sono categoriali, utilizziamo grafici come striplot (), swarmplot (), ecc. Seaborn fornisce l'interfaccia per farlo.
Grafici a dispersione categoriali
In questa sezione, impareremo i grafici a dispersione categoriali.
stripplot ()
stripplot () viene utilizzato quando una delle variabili in esame è categoriale. Rappresenta i dati in ordine ordinato lungo uno qualsiasi degli assi.
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.stripplot(x = "species", y = "petal_length", data = df)
plt.show()
Produzione
Nella trama sopra, possiamo vedere chiaramente la differenza di petal_lengthin ogni specie. Tuttavia, il problema principale con il grafico a dispersione sopra è che i punti sul grafico a dispersione sono sovrapposti. Usiamo il parametro "Jitter" per gestire questo tipo di scenario.
Il jitter aggiunge del rumore casuale ai dati. Questo parametro regolerà le posizioni lungo l'asse categoriale.
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.stripplot(x = "species", y = "petal_length", data = df, jitter = Ture)
plt.show()
Produzione
Ora, la distribuzione dei punti può essere vista facilmente.
Swarmplot ()
Un'altra opzione che può essere utilizzata come alternativa a "Jitter" è la funzione swarmplot(). Questa funzione posiziona ogni punto del grafico a dispersione sull'asse categoriale e quindi evita punti che si sovrappongono -
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.swarmplot(x = "species", y = "petal_length", data = df)
plt.show()
Produzione
Nei grafici a dispersione categoriali che abbiamo trattato nel capitolo precedente, l'approccio diventa limitato nelle informazioni che può fornire sulla distribuzione dei valori all'interno di ciascuna categoria. Adesso, andando oltre, vediamo cosa ci può facilitare con il confronto per categorie.
Box Plots
Boxplot è un modo conveniente per visualizzare la distribuzione dei dati attraverso i loro quartili.
I box plot di solito hanno linee verticali che si estendono dalle scatole che sono chiamate baffi. Questi baffi indicano la variabilità al di fuori dei quartili superiore e inferiore, quindi anche i Box Plots sono definiti comebox-and-whisker trama e box-and-whisker diagramma. Eventuali valori anomali nei dati vengono tracciati come singoli punti.
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.swarmplot(x = "species", y = "petal_length", data = df)
plt.show()
Produzione
I punti sul grafico indicano il valore anomalo.
Trame di violino
Violin Plots è una combinazione del box plot con le stime della densità del kernel. Quindi, questi grafici sono più facili da analizzare e comprendere la distribuzione dei dati.
Usiamo il set di dati dei suggerimenti chiamato per saperne di più sulle trame del violino. Questo set di dati contiene le informazioni relative ai suggerimenti forniti dai clienti in un ristorante.
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('tips')
sb.violinplot(x = "day", y = "total_bill", data=df)
plt.show()
Produzione
I valori di quartile e baffo del boxplot sono mostrati all'interno del violino. Poiché la trama del violino utilizza KDE, la porzione più ampia del violino indica la densità maggiore e la regione stretta rappresenta una densità relativamente inferiore. La gamma Inter-Quartile nel boxplot e la porzione a maggiore densità in kde rientrano nella stessa regione di ciascuna categoria di trama per violino.
Il grafico sopra mostra la distribuzione di total_bill nei quattro giorni della settimana. Ma, oltre a ciò, se vogliamo vedere come si comporta la distribuzione rispetto al sesso, esploriamola nell'esempio sottostante.
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('tips')
sb.violinplot(x = "day", y = "total_bill",hue = 'sex', data = df)
plt.show()
Produzione
Ora possiamo vedere chiaramente il comportamento di spesa tra uomini e donne. Possiamo facilmente affermare che gli uomini fanno più conti delle donne guardando la trama.
E, se la variabile hue ha solo due classi, possiamo abbellire la trama dividendo ogni violino in due invece di due violini in un dato giorno. Entrambe le parti del violino si riferiscono a ciascuna classe nella variabile hue.
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('tips')
sb.violinplot(x = "day", y="total_bill",hue = 'sex', data = df)
plt.show()
Produzione
Nella maggior parte delle situazioni, ci occupiamo di stime dell'intera distribuzione dei dati. Ma quando si tratta di stima della tendenza centrale, abbiamo bisogno di un modo specifico per riassumere la distribuzione. La media e la mediana sono le tecniche utilizzate molto spesso per stimare la tendenza centrale della distribuzione.
In tutte le trame che abbiamo appreso nella sezione precedente, abbiamo effettuato la visualizzazione dell'intera distribuzione. Parliamo ora dei grafici con i quali possiamo stimare la tendenza centrale della distribuzione.
Bar Plot
Il barplot()mostra la relazione tra una variabile categoriale e una variabile continua. I dati sono rappresentati in barre rettangolari dove la lunghezza della barra rappresenta la proporzione dei dati in quella categoria.
Il grafico a barre rappresenta la stima della tendenza centrale. Usiamo il set di dati "titanico" per apprendere i grafici a barre.
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('titanic')
sb.barplot(x = "sex", y = "survived", hue = "class", data = df)
plt.show()
Produzione
Nell'esempio sopra, possiamo vedere che il numero medio di sopravvissuti di maschi e femmine in ogni classe. Dalla trama possiamo capire che è sopravvissuto un numero maggiore di femmine rispetto ai maschi. Sia nei maschi che nelle femmine il maggior numero di sopravvissuti è di prima classe.
Un caso speciale in barplot è mostrare il numero di osservazioni in ciascuna categoria piuttosto che calcolare una statistica per una seconda variabile. Per questo, usiamocountplot().
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('titanic')
sb.countplot(x = " class ", data = df, palette = "Blues");
plt.show()
Produzione
La trama dice che il numero di passeggeri nella terza classe è superiore alla prima e alla seconda classe.
Grafici a punti
I grafici a punti funzionano come i grafici a barre ma in uno stile diverso. Piuttosto che la barra piena, il valore della stima è rappresentato dal punto ad una certa altezza sull'altro asse.
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('titanic')
sb.pointplot(x = "sex", y = "survived", hue = "class", data = df)
plt.show()
Produzione
È sempre preferibile utilizzare set di dati "lunghi da" o "ordinati". Ma a volte quando non ci resta altra scelta che utilizzare un set di dati "wide-form", le stesse funzioni possono essere applicate anche ai dati "wide-form" in una varietà di formati, inclusi i frame di dati Pandas o NumPy bidimensionali array. Questi oggetti devono essere passati direttamente al parametro data, le variabili x e y devono essere specificate come stringhe
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.boxplot(data = df, orient = "h")
plt.show()
Produzione
Inoltre, queste funzioni accettano vettori di oggetti Panda o NumPy piuttosto che variabili in un DataFrame.
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
sb.boxplot(data = df, orient = "h")
plt.show()
Produzione
Il vantaggio principale dell'utilizzo di Seaborn per molti sviluppatori nel mondo Python è perché può prendere l'oggetto DataFrame panda come parametro.
I dati categoriali possono essere visualizzati utilizzando due grafici, è possibile utilizzare le funzioni pointplot()o la funzione di livello superiore factorplot().
Factorplot
Factorplot disegna un grafico categoriale su una FacetGrid. Usando il parametro 'kind' possiamo scegliere la trama come boxplot, violinplot, barplot e stripplot. FacetGrid utilizza pointplot per impostazione predefinita.
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('exercise')
sb.factorplot(x = "time", y = pulse", hue = "kind",data = df);
plt.show()
Produzione
Possiamo usare grafici diversi per visualizzare gli stessi dati usando il kind parametro.
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('exercise')
sb.factorplot(x = "time", y = "pulse", hue = "kind", kind = 'violin',data = df);
plt.show()
Produzione
In factorplot, i dati vengono tracciati su una griglia di faccette.
Cos'è Facet Grid?
Facet grid forma una matrice di pannelli definiti per riga e colonna dividendo le variabili. A causa dei pannelli, un singolo grafico assomiglia a più grafici. È molto utile analizzare tutte le combinazioni in due variabili discrete.
Visualizziamo quanto sopra la definizione con un esempio
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('exercise')
sb.factorplot(x = "time", y = "pulse", hue = "kind", kind = 'violin', col = "diet", data = df);
plt.show()
Produzione
Il vantaggio dell'utilizzo di Facet è che possiamo inserire un'altra variabile nel grafico. Il grafico sopra è diviso in due grafici basati su una terza variabile chiamata "dieta" utilizzando il parametro "col".
Possiamo creare molte sfaccettature di colonna e allinearle con le righe della griglia -
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('titanic')
sb.factorplot("alive", col = "deck", col_wrap = 3,data = df[df.deck.notnull()],kind = "count")
plt.show()
produzione
Il più delle volte, utilizziamo set di dati che contengono più variabili quantitative e l'obiettivo di un'analisi è spesso mettere in relazione tali variabili tra loro. Questo può essere fatto tramite le linee di regressione.
Durante la creazione dei modelli di regressione, spesso controlliamo multicollinearity,dove abbiamo dovuto vedere la correlazione tra tutte le combinazioni di variabili continue e intraprenderemo le azioni necessarie per rimuovere la multicollinearità se esiste. In questi casi, le seguenti tecniche aiutano.
Funzioni per disegnare modelli di regressione lineare
Ci sono due funzioni principali in Seaborn per visualizzare una relazione lineare determinata attraverso la regressione. Queste funzioni sonoregplot() e lmplot().
regplot vs lmplot
regplot | lmplot |
---|---|
accetta le variabili xey in una varietà di formati inclusi semplici array numpy, oggetti serie panda o come riferimenti a variabili in un DataFrame panda | ha i dati come parametro obbligatorio e le variabili x e y devono essere specificate come stringhe. Questo formato di dati è chiamato dati di "forma lunga" |
Disegniamo ora le trame.
Esempio
Tracciare il regplot e quindi lmplot con gli stessi dati in questo esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('tips')
sb.regplot(x = "total_bill", y = "tip", data = df)
sb.lmplot(x = "total_bill", y = "tip", data = df)
plt.show()
Produzione
Puoi vedere la differenza nella dimensione tra due grafici.
Possiamo anche adattare una regressione lineare quando una delle variabili assume valori discreti
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('tips')
sb.lmplot(x = "size", y = "tip", data = df)
plt.show()
Produzione
Adatto a diversi tipi di modelli
Il modello di regressione lineare semplice utilizzato sopra è molto semplice da adattare, ma nella maggior parte dei casi i dati non sono lineari e i metodi di cui sopra non possono generalizzare la retta di regressione.
Usiamo il set di dati di Anscombe con i grafici di regressione -
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('anscombe')
sb.lmplot(x="x", y="y", data=df.query("dataset == 'I'"))
plt.show()
In questo caso, i dati si adattano bene al modello di regressione lineare con minore varianza.
Vediamo un altro esempio in cui i dati hanno una deviazione elevata che mostra che la linea di adattamento migliore non è buona.
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('anscombe')
sb.lmplot(x = "x", y = "y", data = df.query("dataset == 'II'"))
plt.show()
Produzione
Il grafico mostra l'elevata deviazione dei punti dati dalla linea di regressione. Tale ordine superiore non lineare può essere visualizzato utilizzando illmplot() e regplot()Questi possono adattarsi a un modello di regressione polinomiale per esplorare tipi semplici di tendenze non lineari nel set di dati -
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('anscombe')
sb.lmplot(x = "x", y = "y", data = df.query("dataset == 'II'"),order = 2)
plt.show()
Produzione
Un approccio utile per esplorare i dati di media dimensione consiste nel disegnare più istanze dello stesso grafico su diversi sottoinsiemi del tuo insieme di dati.
Questa tecnica è comunemente chiamata "reticolo", o "trellis", ed è correlata all'idea di "piccoli multipli".
Per utilizzare queste funzionalità, i tuoi dati devono essere in un Pandas DataFrame.
Rappresentazione grafica di piccoli multipli di sottoinsiemi di dati
Nel capitolo precedente, abbiamo visto l'esempio FacetGrid in cui la classe FacetGrid aiuta a visualizzare la distribuzione di una variabile così come la relazione tra più variabili separatamente all'interno dei sottoinsiemi del tuo set di dati usando più pannelli.
È possibile disegnare una FacetGrid con un massimo di tre dimensioni: riga, colore e tonalità. I primi due hanno un'ovvia corrispondenza con la matrice di assi risultante; pensa alla variabile di tonalità come a una terza dimensione lungo un asse di profondità, dove diversi livelli sono tracciati con colori diversi.
FacetGrid object accetta un dataframe come input ei nomi delle variabili che formeranno le dimensioni di riga, colonna o tonalità della griglia.
Le variabili devono essere categoriali e i dati a ciascun livello della variabile verranno utilizzati per un aspetto lungo quell'asse.
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('tips')
g = sb.FacetGrid(df, col = "time")
plt.show()
Produzione
Nell'esempio precedente, abbiamo appena inizializzato il file facetgrid oggetto che non disegna nulla su di loro.
L'approccio principale per visualizzare i dati su questa griglia è con il FacetGrid.map()metodo. Esaminiamo la distribuzione dei suggerimenti in ciascuno di questi sottoinsiemi, utilizzando un istogramma.
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('tips')
g = sb.FacetGrid(df, col = "time")
g.map(plt.hist, "tip")
plt.show()
Produzione
Il numero di grafici è più di uno a causa del parametro col. Abbiamo discusso del parametro col nei nostri capitoli precedenti.
Per creare un grafico relazionale, passare i nomi di più variabili.
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('tips')
g = sb.FacetGrid(df, col = "sex", hue = "smoker")
g.map(plt.scatter, "total_bill", "tip")
plt.show()
Produzione
PairGrid ci permette di disegnare una griglia di sottotrame utilizzando lo stesso tipo di diagramma per visualizzare i dati.
A differenza di FacetGrid, utilizza diverse coppie di variabili per ogni sottotrama. Forma una matrice di sotto-grafici. A volte è anche chiamata "matrice del grafico a dispersione".
L'utilizzo di pairgrid è simile a facetgrid. Inizializza prima la griglia e poi passa alla funzione di plottaggio.
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
g = sb.PairGrid(df)
g.map(plt.scatter);
plt.show()
È anche possibile tracciare una funzione diversa sulla diagonale per mostrare la distribuzione univariata della variabile in ogni colonna.
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
g = sb.PairGrid(df)
g.map_diag(plt.hist)
g.map_offdiag(plt.scatter);
plt.show()
Produzione
Possiamo personalizzare il colore di questi grafici utilizzando un'altra variabile categoriale. Ad esempio, il set di dati dell'iride ha quattro misurazioni per ciascuna delle tre diverse specie di fiori di iris in modo da poter vedere come differiscono.
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
g = sb.PairGrid(df)
g.map_diag(plt.hist)
g.map_offdiag(plt.scatter);
plt.show()
Produzione
Possiamo usare una funzione diversa nei triangoli superiore e inferiore per vedere diversi aspetti della relazione.
Esempio
import pandas as pd
import seaborn as sb
from matplotlib import pyplot as plt
df = sb.load_dataset('iris')
g = sb.PairGrid(df)
g.map_upper(plt.scatter)
g.map_lower(sb.kdeplot, cmap = "Blues_d")
g.map_diag(sb.kdeplot, lw = 3, legend = False);
plt.show()