Trama de violín de Seaborn – Tutorial y ejemplos

T

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 una trama de violín en Seaborn.

Los gráficos 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 de granos 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 tramas de violín.

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

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

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

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

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

Luego, necesitaremos 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:

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:

       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 funciones continuas y las guardaremos como variables para pasar a las funciones de Seaborn:

country = dataframe.country
continent = dataframe.continent
population = dataframe.population
life_exp = dataframe.life_exp
gdp_cap = dataframe.gdp_cap

Trazar una trama de violín simple en Seaborn

Ahora que hemos cargado los datos y seleccionado nuestras características preferidas, podemos crear la trama del violín.

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

Pasamos el marco de datos 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:

sns.violinplot(x=life_exp)

plt.show()

Alternativamente, no necesita extraer las características de antemano. Suministrando el data argumento, y asignándolo a nuestro DataFrame, puede simplemente hacer referencia al nombre de la variable, que luego se hace coincidir con el conjunto de datos:

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 hemos proporcionado el life_exp variable. La mayoría de las veces, también querremos separar una variable como esta en función de otra variable, como country o continent.

Trazado de una gráfica de violín con variables X e Y

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 graficamos todos, habrá demasiados para verlos prácticamente y la figura estará demasiado abarrotada. Podríamos crear un subconjunto del conjunto de datos y simplemente trazar, digamos, 10 países.

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

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

Personalización de la trama

Podemos personalizar la trama de nuestro violín de diferentes maneras.

Cambiar las etiquetas de la 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 el set_title() y set_label() funciones después de crear un objeto de ejes. Simplemente pasamos el título que queremos darle a nuestra trama al set_title() función.

Para etiquetar los ejes, usamos el set() función y proporcionar etiquetas a la xlabel y ylabel argumentos, o use el contenedor set_xlabel()/set_ylabel() funciones:

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 de personalizar el gráfico es asignarle colores específicos. Podemos crear una lista de colores preseleccionados y pasarlos al palette parámetro:

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

Superposición de Swarmplot sobre trama de violín 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 objeto de figura única y luego creamos dos gráficos diferentes:

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 el estilo de la trama del violín con Seaborn

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

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

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

Subparcelas de violín con Seaborn

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

Luego solo usamos el add_subplot() función y especificar en qué lugar de la cuadrícula queremos colocar la subparcela actual, creando la gráfica como lo haríamos normalmente, usando el objeto ejes.

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

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 parcelas de violín por tono

Una cosa realmente útil que se puede hacer con Violin Plots es agrupar por matiz. Si tiene un valor categórico, tiene dos valores (normalmente, un true/false-variable de estilo), puede agrupar las parcelas por matiz.

Por ejemplo, podría tener un conjunto de datos de personas y un employment columna, con employed y unemployed como valores. A continuación, puede agrupar 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 hacer una nosotros mismos. Calculemos la esperanza de vida media de un subconjunto de países. Digamos, calculamos la esperanza de vida media de los países europeos.

Entonces, podemos asignar un Yes/No valor a una nueva columna – above_average_life_exp para cada país. Si la esperanza de vida media es superior a la media del continente, este valor es Yes, y viceversa:

# 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:

             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 en aras de la brevedad.

Ahora, seleccionemos un subconjunto más pequeño de estos países usando europe.head() y trazar diagramas de violín agrupados por la nueva columna que hemos insertado:

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. Sin embargo, incluso esto no nos dice todo. Quizás 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.

División de parcelas de violín por tono

Seaborn Violin Plots te deja pasar en el split argumento, que se puede establecer en True o False.

Si lo configura en Truey un hue argumento está presente, dividirá los violines entre los hue valores.

En nuestro caso, un lado del violín representará el lado izquierdo del violín como entradas con una esperanza de vida superior al promedio, mientras que el lado derecho se utilizará para trazar las expectativas de vida inferiores al promedio:

Conclusión

En este tutorial, hemos repasado varias formas de trazar una trama de violín usando Seaborn y Python. También cubrimos cómo personalizar y cambiar las etiquetas y el color, así como superponer Swarmplots, crear subtramas de múltiples gráficos de violín y, finalmente, cómo agrupar los gráficos por tono y crear gráficos de violín divididos en función de una variable.

 

Data Visualization in Python, un libro para desarrolladores de Python principiantes e intermedios, lo guiará a través de la manipulación simple de datos con Pandas, cubrirá bibliotecas de trazado centrales como Matplotlib y Seaborn, y le mostrará cómo aprovechar las bibliotecas declarativas y experimentales como Altair.

 

About the author

Ramiro de la Vega

Bienvenido a Pharos.sh

Soy Ramiro de la Vega, Estadounidense con raíces Españolas. Empecé a programar hace casi 20 años cuando era muy jovencito.

Espero que en mi web encuentres la inspiración y ayuda que necesitas para adentrarte en el fantástico mundo de la programación y conseguir tus objetivos por difíciles que sean.

Add comment

Sobre mi

Últimos Post

Etiquetas

Esta web utiliza cookies propias para su correcto funcionamiento. Al hacer clic en el botón Aceptar, aceptas el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Más información
Privacidad