Seaborn Violin Plot - Tutorial y ejemplos

En este tutorial, repasaremos cómo trazar Violin Plots con Seaborn. Repasaremos diagramas de violín personalizados simples y avanzados con ejemplos.

Introducción

Seaborn es una de las bibliotecas de visualización de datos más utilizadas en Python, como una extensión de Matplotlib. Ofrece una API simple, intuitiva pero altamente personalizable para la visualización de datos.

En este tutorial, veremos cómo trazar un gráfico de violín en Seaborn.

Los diagramas de violín se utilizan para visualizar distribuciones de datos, mostrando el rango, la mediana y la distribución de los datos.

Los diagramas de violín muestran las mismas estadísticas de resumen que los diagramas de caja, pero también incluyen Estimaciones de densidad del kernel que representan la forma/distribución de los datos.

Importación de datos

Para empezar, querremos elegir un conjunto de datos que sea adecuado para la creación de diagramas de violín.

El conjunto de datos debe tener características numéricas continuas. Esto se debe a que los diagramas de violín se utilizan para visualizar distribuciones de datos continuos. Muestran el rango, la mediana y la distribución de los datos.

Los diagramas de violín muestran esencialmente las mismas estadísticas de resumen que los diagramas de caja, pero también incluyen información adicional. La forma del “violín” en un gráfico de violín es una estimación de la densidad del kernel que representa la forma/distribución de los datos.

Para este tutorial, trabajaremos con el conjunto de datos Gapminder.

Comenzaremos importando Seaborn, el módulo PyPlot de Matplotlib y Pandas:

1
2
3
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

A continuación, tendremos que importar los datos. Imprimiremos el encabezado del conjunto de datos para asegurarnos de que los datos se hayan cargado correctamente y para ver los nombres de las columnas/características.

También verificaremos para asegurarnos de que no falten datos:

1
2
3
dataframe = pd.read_csv("gapminder_full.csv", error_bad_lines=False, encoding="ISO-8859-1")
print(dataframe.head())
print(dataframe.isnull().values.any())

Esto resulta en:

1
2
3
4
5
6
       country  year  population continent  life_exp     gdp_cap
0  Afghanistan  1952     8425333      Asia    28.801  779.445314
1  Afghanistan  1957     9240934      Asia    30.332  820.853030
2  Afghanistan  1962    10267083      Asia    31.997  853.100710
3  Afghanistan  1967    11537966      Asia    34.020  836.197138
4  Afghanistan  1972    13079460      Asia    36.088  739.981106

Seleccionaremos nuestras características continuas y las guardaremos como variables para pasarlas a las funciones de Seaborn:

1
2
3
4
5
country = dataframe.country
continent = dataframe.continent
population = dataframe.population
life_exp = dataframe.life_exp
gdp_cap = dataframe.gdp_cap

Trazado de un diagrama de violín simple en Seaborn

Ahora que hemos cargado los datos y seleccionado las características de nuestra elección, podemos crear el diagrama de violín.

Para crear una trama de violín, solo usamos la función violinplot() en Seaborn.

Pasamos el dataframe así como las variables que queremos visualizar. Podemos pasar solo la variable X y la función calculará automáticamente los valores en el eje Y:

1
2
3
sns.violinplot(x=life_exp)

plt.show()

Alternativamente, no necesita extraer las características de antemano. Al proporcionar el argumento data y asignarlo a nuestro DataFrame, simplemente puede hacer referencia al nombre de la variable, que luego se compara con el conjunto de datos:

1
sns.violinplot(x="life_exp", data = dataframe)

Esto produce exactamente el mismo resultado.

Tenga en cuenta: En esta imagen, Seaborn está trazando la distribución de la esperanza de vida en todos los países, ya que solo proporcionamos la variable life_exp. La mayoría de las veces, también querremos separar una variable como esta en función de otra variable, como país o continente.

Trazado de un diagrama de violín con variables X e Y {#trazado de un diagrama de violín con variables xandy}

Aquí pasaremos una variable X categórica y una variable Y continua, ya que hay una distribución específica que nos gustaría ver segmentada por tipo.

En este conjunto de datos, tenemos muchos países. Si los trazamos todos, habrá demasiados para verlos prácticamente y la figura estará demasiado abarrotada. Podríamos crear subconjuntos del conjunto de datos y solo graficar, digamos, 10 países.

En cambio, también podríamos trazar por continente.

1
sns.violinplot(x=continent, y=life_exp, data=dataframe)

Personalización de la trama

Podemos personalizar nuestra trama de violín de diferentes maneras.

Cambiar etiquetas de trama de violín con Seaborn

Digamos que nos gustaría agregar algunos títulos y etiquetas a nuestro gráfico para ayudar a otros a interpretar los datos. Aunque Seaborn etiquetará automáticamente los ejes X e Y, es posible que deseemos cambiar las etiquetas.

Esto se puede hacer con las funciones set_title() y set_label() después de crear un objeto de ejes. Simplemente pasamos el título que queremos darle a nuestra trama a la función set_title().

Para etiquetar los ejes, usamos la función set() y proporcionamos etiquetas a los argumentos xlabel e ylabel, o usamos las funciones de envoltura set_xlabel()/set_ylabel():

1
2
3
4
5
6
ax = sns.violinplot(x=continent, y=life_exp)
ax.set_title("Life Expectancy By Country")
ax.set_ylabel("Gapminder Life Expectancy")
ax.set_xlabel("Nations")

plt.show()

Cambiar el color de la trama del violín con Seaborn

Una forma en que podemos personalizar la trama es asignarle colores específicos. Podemos crear una lista de colores preseleccionados y pasarlos al parámetro paleta:

1
2
3
4
5
6
7
8
colors_list = ['#78C850', '#F08030',  '#6890F0',  '#A8B820',  '#F8D030', '#E0C068', '#C03028', '#F85888', '#98D8D8']

ax = sns.violinplot(x=continent, y=life_exp, palette=colors_list)
ax.set_title("Life Expectancy By Country")
ax.set_ylabel("Gapminder Life Expectancy")
ax.set_xlabel("Nations")

plt.show()

Overlaying Swarmplot Over Violin Plot en Seaborn

Incluso podríamos superponer un Swarmplot en el Violin Plot para ver la distribución y las muestras de los puntos que componen esa distribución. Para hacer esto, simplemente creamos un único objeto de figura y luego creamos dos gráficos diferentes:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
colors_list = ['#78C850', '#F08030',  '#6890F0',  '#A8B820',  '#F8D030', '#E0C068', '#C03028', '#F85888', '#98D8D8']

plt.figure(figsize=(10,6))
sns.violinplot(x=continent, y=life_exp,palette=colors_list)
sns.swarmplot(x=continent, y=life_exp, color="k", alpha=0.8)
plt.title("Life Expectancy By Country")
plt.ylabel("Gapminder Life Expectancy")
plt.xlabel("Nations")

plt.show()

Cambiar estilo de trama de violín con Seaborn

Podemos cambiar fácilmente el estilo y la paleta de colores de nuestro diagrama usando las funciones set_style() y set_palette() respectivamente.

Seaborn admite varias opciones diferentes para cambiar el estilo y la paleta de la figura:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
plt.figure(figsize=(10,6))
sns.set_palette("RdBu")
sns.set_style("darkgrid")
sns.violinplot(x=continent, y=life_exp, data=dataframe)
sns.swarmplot(x=continent, y=life_exp, data=dataframe, color="k", alpha=0.8)
plt.title("Life Expectancy By Country")
plt.ylabel("Gapminder Life Expectancy")
plt.xlabel("Nations")

plt.show()

Subplotting Violin Plots with Seaborn

Finalmente, si quisiéramos dividir las columnas en sus propias subtramas, podríamos hacerlo creando una figura y luego usando la función add_gridspec() para crear una cuadrícula donde podamos colocar nuestra subtrama.

Luego simplemente usamos la función add_subplot() y especificamos en qué parte de la cuadrícula queremos colocar la subtrama actual, creando la trama como lo haríamos normalmente, usando el objeto de ejes.

Aquí, podemos configurar y=variable o usar data=variable.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
fig = plt.figure(figsize=(6, 6))
gs = fig.add_gridspec(1, 3)

ax = fig.add_subplot(gs[0, 0])

sns.violinplot(data=population)
ax.set_xlabel("Population")

ax = fig.add_subplot(gs[0, 1])
sns.violinplot(data=life_exp)
ax.set_xlabel("Life Exp.")

ax = fig.add_subplot(gs[0, 2])
sns.violinplot(data=gdp_cap)
ax.set_xlabel("GDP Capacity")

fig.tight_layout()
plt.show()

Agrupación de diagramas de violín por tono

Una cosa realmente útil que hacer con Violin Plots es agrupar por tonalidad. Si tiene un valor categórico, que tiene dos valores (normalmente, una variable de estilo verdadero/falso), puede agrupar gráficos por tono.

Por ejemplo, podría tener un conjunto de datos de personas y una columna de “empleo”, con “empleado” y “desempleado” como valores. A continuación, puede agrupar las parcelas de violín por "matiz", estos dos tipos de empleo.

Dado que el conjunto de datos de Gapminder no tiene una columna como esta, podemos crear una nosotros mismos. Calculemos la esperanza de vida media para un subconjunto de países. Digamos que calculamos la esperanza de vida media de los países europeos.

Luego, podemos asignar un valor /No a una nueva columna: por encima del promedio de vida útil para cada país. Si la esperanza de vida promedio es más alta que el promedio de todo el continente, este valor es “Sí”, y viceversa:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
# Separate European countries from the original dataset
europe = dataframe.loc[dataframe["continent"] == "Europe"]

# Calculate mean of the `life_exp` variable
avg_life_exp = dataframe["life_exp"].mean()

# Declare an empty list
above_average_life_exp = []

# Iterate through the rows in the dataset, assigning Yes/No
# Depending on the value of the variable in the iterated row
for index, row in europe.iterrows():
    if row["life_exp"] > avg_life_exp:
        above_average_life_exp.append("Yes")
    else:
        above_average_life_exp.append("No")

# Add new column to dataset
europe["above_average_life_exp"] = above_average_life_exp

Ahora, si imprimimos nuestro conjunto de datos, tenemos algo como:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
             country  year  population continent  life_exp       gdp_cap avle
12           Albania  1952     1282697    Europe    55.230   1601.056136  No
13           Albania  1957     1476505    Europe    59.280   1942.284244  No
14           Albania  1962     1728137    Europe    64.820   2312.888958  Yes
15           Albania  1967     1984060    Europe    66.220   2760.196931  Yes
16           Albania  1972     2263554    Europe    67.690   3313.422188  Yes
...              ...   ...         ...       ...       ...           ...  ...
1603  United Kingdom  1987    56981620    Europe    75.007  21664.787670  Yes
1604  United Kingdom  1992    57866349    Europe    76.420  22705.092540  Yes
1605  United Kingdom  1997    58808266    Europe    77.218  26074.531360  Yes
1606  United Kingdom  2002    59912431    Europe    78.471  29478.999190  Yes
1607  United Kingdom  2007    60776238    Europe    79.425  33203.261280  Yes

El nombre de la variable se trunca a avle por motivos de brevedad.

Ahora, seleccionemos un subconjunto más pequeño de estos países usando europe.head() y tracemos las parcelas Violin agrupadas por la nueva columna que hemos insertado:

1
2
3
4
5
6
7
8
europe = europe.tail(50)

ax = sns.violinplot(x=europe.country, y=europe.life_exp, hue=europe.above_average_life_exp)
ax.set_title("Life Expectancy By Country")
ax.set_ylabel("Gapminder Life Expectancy")
ax.set_xlabel("Nations")

plt.show()

Esto ahora resulta en:

Ahora, los países con una esperanza de vida inferior a la media están coloreados de naranja, mientras que los demás países están coloreados de azul. Aunque, incluso esto no nos dice todo. Tal vez nos gustaría comprobar cuántas personas en Turquía tienen una esperanza de vida inferior a la media.

Aquí es donde entra en juego la división.

Splitting Violin Plots de Hue

Seaborn Violin Plots le permite pasar el argumento split, que se puede configurar como True o False.

Si lo establece en True, y hay presente un argumento hue, dividirá los violines entre los valores hue.

En nuestro caso, un lado del violín representará el lado izquierdo del violín como entradas con una esperanza de vida superior a la media, mientras que el lado derecho se utilizará para trazar una esperanza de vida inferior a la media:

split violin plots by hue seaborn

Conclusión

En este tutorial, hemos repasado varias formas de trazar un diagrama de violín usando Seaborn y Python. También hemos cubierto cómo personalizar y cambiar las etiquetas y el color, así como superponer Swarmplots, subtrazar múltiples Violin Plots y, finalmente, cómo agrupar gráficos por tonalidad y crear Dividir Violin Plots en función de una variable.

Si está interesado en Visualización de datos y no sabe por dónde empezar, asegúrese de consultar nuestro paquete de libros en [Visualización de datos en Python](https://gum.co/data-visualization -en-paquete-de-libros-de-python):

Visualización de datos en Python Vuélvase peligroso con la visualización de datos ✅ Garantía de devolución de dinero de 30 días sin preguntas ✅ Principiante a Avanzado ✅ Actualizado periódicamente de forma gratuita (última actualización en abril de 2021) ✅ Actualizado con recursos y guías adicionales

Visualización de datos en Python con Matplotlib y Pandas es un libro diseñado para llevar a los principiantes absolutos a Pandas y Matplotlib, con conocimientos básicos de Python, y permitirles construir una base sólida para el trabajo avanzado con estas bibliotecas, desde gráficos simples. a gráficos 3D animados con botones interactivos.

Sirve como una guía detallada que le enseñará todo lo que necesita saber sobre Pandas y Matplotlib, incluido cómo construir tipos de gráficos que no están integrados en la propia biblioteca.

Visualización de datos en Python, un libro para desarrolladores principiantes e intermedios de Python, lo guía a través de la manipulación de datos simple con Pandas, cubre bibliotecas de trazado centrales como Matplotlib y Seaborn, y le muestra cómo aprovechar las bibliotecas declarativas y experimentales. como Altair. Más específicamente, a lo largo de 11 capítulos, este libro cubre 9 bibliotecas de Python: Pandas, Matplotlib, Seaborn, Bokeh, Altair, Plotly, GGPlot, GeoPandas y VisPy.

Sirve como una guía práctica única para la visualización de datos, en una plétora de herramientas que podría usar en su carrera.