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()

Produzione