pairgrid Seaborn: usando kdeplot con 2 tonalità

Question

Qui è il mio tentativo di tracciare una trama pairgrid che utilizzano il kdeplot nella parte inferiore con 2 tonalità:

Il mio script è:

import seaborn as sns 
g = sns.PairGrid(df2,hue='models') 
g.map_upper(plt.scatter) 
g.map_lower(sns.kdeplot) 
g.map_diag(sns.distplot) 

C'è un modo in Seaborn 0.6.0 per usare più scale di colori nel kdeplot di map_lower in base alla tonalità?

In questo caso, la tonalità ha solo 2 valori. Forse mi manca qualcosa di ovvio.

Answer 1

È necessario creare la propria funzione di stampa chiamata da PairGrid, con il formato myplot (x, y, ** kws). kws contiene il campo "colore" creato automaticamente da PairGrid o da te specificato nell'argomento Tavolozza di PairGrid.

Per controllare come si seleziona la mappa colori dal colore indicato in Palette è meglio impostare manualmente questo argomento con un dizionario che collega i valori delle variabili della variabile passati a tonalità con i colori di propria scelta.

Ecco un esempio per solo 4 colori: rosso, verde, blu e magenta. Conducendo alle mappe dei colori: rossi, verdi, blu e viola.

Infer cmap dal colore

def infer_cmap(color): 
    if color == (0., 0., 1.): 
     return 'Blues' 
    elif color == (0., 0.5, 0.): 
     return 'Greens' 
    elif color == (1., 0., 0.): 
     return 'Reds' 
    elif color == (0.75, 0., 0.75): 
     return 'Purples' 

Aggiungi tonalità di colore a una kde trama

def kde_hue(x, y, **kws): 
    ax = plt.gca() 
    cmap = infer_cmap(kws['color']) 
    sns.kdeplot(data=x, data2=y, ax=ax, shade=True, shade_lowest=False, cmap=cmap, **kws) 
    return ax 

Creare il PairGrid

colors = ['b', 'g', 'r', 'm'] 
var = 'models' 

color_dict = {} 
for idx, v in enumerate(np.unique(df2[var])): 
    color_dict[v] = colors[idx] 
g = sns.PairGrid(df2, hue=var, palette=color_dict) 
g = g.map_diag(sns.kdeplot) 
g = g.map_upper(plt.scatter) 
g = g.map_lower(kde_hue) 
g = g.add_legend() 
plt.show() 
plt.close() 

Answer 2

ho avuto modo di questa domanda quando si cerca di utilizzare hue su kdeplot() o distplot() che non è un para supportato metro. Questo funziona

g = sns.FacetGrid(df_rtn, hue="group") 
g = g.map(sns.kdeplot, "variable") 
# or 
g = g.map(sns.distplot, "variable") 

Answer 3

Come visto nell'esempio di Martin, una funzione wrapper deve essere creato per istruire sns.kdeplot su ciò mappe colore da utilizzare. Ecco un esempio simile che dovrebbe essere più facile da capire:

# We will use seaborn 'Set1' color pallet 

>>> print(sns.color_palette('Set1')) 

[(0.89411765336990356, 0.10196078568696976, 0.10980392247438431), 
(0.21602460800432691, 0.49487120380588606, 0.71987698697576341), 
(0.30426760128900115, 0.68329106055054012, 0.29293349969620797), 
(0.60083047361934883, 0.30814303335021526, 0.63169552298153153), 
(1.0, 0.50591311045721465, 0.0031372549487095253), 
(0.99315647868549117, 0.9870049982678657, 0.19915417450315812)] 

La mappa colori acquisisce il colore in base al pallet. Il pallet predefinito è verde - (0., 0., 1.) e blu - (0., 0.5, 0.). Tuttavia, stiamo usando il pallet di cui sopra che ha diverse tuple RBG.

def infer_cmap(color): 
    hues = sns.color_palette('Set1') 
    if color == hues[0]: 
     return 'Reds' 
    elif color == hues[1]: 
     return 'Blues' 

def kde_color_plot(x, y, **kwargs): 
    cmap = infer_cmap(kwargs['color']) 
    ax = sns.kdeplot(x, y, shade=True, shade_lowest=False, cmap=cmap, **kwargs) 
    return ax 

g = sns.PairGrid(df, hue='left', vars=['satisfaction_level', 'last_evaluation'], palette='Set1') 
g = g.map_upper(plt.scatter, s=1, alpha=0.5) 
g = g.map_lower(kde_color_plot) 
g = g.map_diag(sns.kdeplot, shade=True); 

Answer 4

Penso che utilizzando il hue_kwds in PairGrid è un easyer molto. Ho trovato una bella spiegazione qui Plotting on data-aware grids, perché il documento in PairGrid non è abbastanza chiaro per me.

Si può anche lasciare gli altri aspetti della trama variano tra i vari livelli della variabile tonalità , che possono essere utili per realizzare grafici che saranno più comprensibili quando stampato in bianco e nero.Per fare ciò, passare un dizionario a hue_kws dove le chiavi sono i nomi della funzione di plottaggio Gli argomenti delle parole chiave sono valori di valori di parole chiave, uno per ciascun livello di della variabile di tonalità.

In sostanza, hue_kws è un ditt di elenchi. Le parole chiave vengono passate alle singole funzioni di tracciamento con i valori della loro lista, una per ciascun livello della variabile hue. Vedere l'esempio di codice qui sotto.

Sto usando una colonna numerica per la tonalità nella mia analisi, ma dovrebbe funzionare anche qui. In caso contrario, è possibile mappare facilmente ciascun valore univoco di "modelli" in intero.

Rubare dalla bella risposta da Martin Perez vorrei fare qualcosa di simile:

EDIT: completo esempio di codice

EDIT 2: ho scoperto che kdeplot non gioca bene con le etichette numeriche. Cambiando il codice di conseguenza.

# generate data: sorry, I'm lazy and sklearn make it easy. 
n = 1000 
from sklearn.datasets.samples_generator import make_blobs 
X, y = make_blobs(n_samples=n, centers=3, n_features=3,random_state=0) 

df2 = pd.DataFrame(data=np.hstack([X,y[np.newaxis].T]),columns=['X','Y','Z','model']) 
# distplot has a problem witht the color being a number!!! 
df2['model'] = df2['model'].map('model_{}'.format) 

list_of_cmaps=['Blues','Greens','Reds','Purples'] 
g = sns.PairGrid(df2,hue='model', 
     # this is only if you use numerical hue col 
#  vars=[i for i in df2.columns if 'm' not in i], 
    # the first hue value vill get cmap='Blues' 
    # the first hue value vill get cmap='Greens' 
    # and so on 
    hue_kws={"cmap":list_of_cmaps}, 
    ) 
g.map_upper(plt.scatter) 
g.map_lower(sns.kdeplot,shade=True, shade_lowest=False) 
g.map_diag(sns.distplot) 
# g.map_diag(plt.hist) 
g.add_legend() 

Ordinamento list_of_cmaps si dovrebbe essere in grado di assegnare una particolare sfumatura a un livello specifico della vostra variabile categoriale.

Un aggiornamento sarebbe creare dinamicamente list_of_cmaps in base al numero di livelli necessari.