Guía definitiva de mapas de calor en Seaborn con Python

    Introducción

    Un mapa de calor es una técnica de visualización de datos que utiliza el color para mostrar cómo cambia un valor de interés en función de los valores de otras dos variables.

    Por ejemplo, podría usar un mapa de calor para comprender cómo varía la contaminación del aire según la hora del día en un conjunto de ciudades.

    Otro caso, quizás más raro, de usar mapas de calor es observar el comportamiento humano: puede crear visualizaciones de cómo las personas usan las redes sociales, cómo cambiaron sus respuestas en las encuestas a lo largo del tiempo, etc. para instituciones psicológicas que suelen enviar encuestas de autoevaluación a los pacientes.

    Aquí hay dos mapas de calor que muestran las diferencias en cómo dos usuarios usan Twitter:

    Estos gráficos contienen todos los componentes principales de un mapa de calor. Fundamentalmente es una cuadrícula de cuadrados de colores donde cada cuadrado, o bin, marca la intersección de los valores de dos variables que se extienden a lo largo de los ejes horizontal y vertical.

    En este ejemplo, estas variables son:

    • La hora del dia
    • El minuto de la hora

    Los cuadrados están coloreados de acuerdo con la cantidad de tweets que caen en cada contenedor de hora / minuto. Al lado de la cuadrícula hay una leyenda que nos muestra cómo se relaciona el color con los valores de recuento. En este caso, los colores más claros (o cálidos) significan más tweets y los más oscuros (o más fríos) significan menos. ¡De ahí el nombre mapa de calor!

    Los mapas de calor son más útiles para identificar patrones en grandes cantidades de datos de un vistazo. Por ejemplo, la franja más oscura y fría de la mañana indica que ambos candidatos no twittean mucho antes del mediodía. Además, el segundo usuario tuitea con mucha más frecuencia que el primer usuario, con una línea de corte más nítida a las 10 a.m., mientras que el primer usuario no tiene una línea tan clara. Esto se puede atribuir a la programación personal durante el día, donde el segundo usuario generalmente termina un trabajo asignado a las 10 a.m., seguido de la verificación en las redes sociales y su uso.

    Los mapas de calor suelen ser un buen punto de partida para análisis más sofisticados. Pero también es una técnica de visualización llamativa, lo que la convierte en una herramienta útil para la comunicación.

    En este tutorial, le mostraremos cómo crear un mapa de calor como el anterior utilizando la biblioteca Seaborn en Python.

    Seaborn es una biblioteca de visualización de datos construida sobre Matplotlib. Juntos, son los líderes de facto cuando se trata de bibliotecas de visualización en Python.

    Seaborn tiene una API de mayor nivel que Matplotlib, lo que nos permite automatizar gran parte de la personalización y las pequeñas tareas que normalmente tendríamos que incluir para que los gráficos de Matplotlib sean más adecuados para el ojo humano. También se integra estrechamente con las estructuras de datos de Pandas, lo que facilita el procesamiento previo y la visualización de datos. También tiene muchas parcelas integradas, con útiles valores predeterminados y un estilo atractivo.

    En esta guía, cubriremos tres secciones principales:

    • Preparación de datos
    • Trazar un mapa de calor
    • Mejores prácticas y personalización de mapas de calor

    ¡Empecemos!

    Preparación de un conjunto de datos para crear un mapa de calor con Seaborn

    Carga de un conjunto de datos de ejemplo con Pandas

    Tenga en cuenta: esta guía se escribió con Python 3.8, Seaborn 0.11.0 y Pandas 1.1.2.

    Para esta guía, utilizaremos un conjunto de datos que contiene las marcas de tiempo de los tweets publicados por dos de los candidatos presidenciales de EE. UU. De 2020 en ese momento, Joe Biden y Donald Trump, entre enero de 2017 y septiembre de 2020. Una descripción del conjunto de datos y cómo fue creado se puede encontrar aquí .

    Un ejercicio divertido en casa podría ser crear tu propio conjunto de datos a partir de los tuits propios o de un amigo y comparar tus hábitos de uso de las redes sociales.

    Nuestra primera tarea es cargar esos datos y transformarlos en la forma que Seaborn espera, y es fácil para nosotros trabajar.

    Usaremos la biblioteca de Pandas para cargar y manipular datos:

    import pandas as pd
    

    Podemos usar la read_csv()función Pandas para cargar el conjunto de datos de recuento de tweets. Puede pasar la URL que apunta al conjunto de datos o descargarla y hacer referencia al archivo manualmente:

    data_url = "https://bit.ly/3cngqgL" # or "path/to/biden_trump_tweets.csv"
    df = pd.read_csv(data_url, 
                     parse_dates=['date_utc'], 
                     dtype={'hour_utc':int,'minute_utc':int,'id':str}
                    )
    

    Siempre vale la pena usar el headmétodo para examinar las primeras filas del DataFrame, para familiarizarse con su forma:

    df.head()
    

    id
    nombre de usuario
    date_utc
    hour_utc
    minute_utc
    retweets
    01234

    815422340540547073realDonaldTrump2017-01-01 05:00:10+00:005027134
    815930688889352192realDonaldTrump2017-01-02 14:40:10+00:00144023930
    815973752785793024realDonaldTrump2017-01-02 17:31:17+00:00173114119
    815989154555297792realDonaldTrump2017-01-02 18:32:29+00:0018323193
    815990335318982656realDonaldTrump2017-01-02 18:37:10+00:0018377337

    Aquí, hemos impreso los primeros 5 elementos en DataFrame. Primero tenemos el índice de cada fila, seguido por el iddel tweet, el usernamedel usuario que twitteó ese tweet, así como la información relacionada con el tiempo como date_utc, hour_utcy minute_utc.

    Finalmente, tenemos el número de retweetsal final, que se puede usar para verificar si hay una relación interesante entre el contenido de los tweets y la «atención» que recibió.

    Transformar los datos en un DataFrame de formato ancho

    Es común encontrar datos de registro como este organizados en un formato largo (o ordenado). Esto significa que hay una columna para cada variable y cada fila de datos es una única observación (valor específico) de esas variables. Aquí, cada tweet es cada variable. Cada fila corresponde a un tweet y contiene datos sobre él.

    Pero, conceptualmente, un mapa de calor requiere que los datos se organicen en una forma corta (o amplia). Y, de hecho, la biblioteca de Seaborn requiere que tengamos los datos en esta forma para producir visualizaciones de mapas de calor como las que hemos visto antes.

    Los datos de formato ancho tienen los valores de las variables independientes como encabezados de fila y columna y los valores de la variable dependiente están contenidos en las celdas.

    Esto básicamente significa que estamos usando todas las propiedades que no estamos observando como categorías. Tenga en cuenta que algunas categorías aparecen más de una vez. Por ejemplo, en la tabla original, tenemos algo como:

    nombre de usuariohour_utcminuto_utc
    realDonaldTrump124
    realDonaldTrump130
    realDonaldTrump124

    Usando el principio de categoría, podemos acumular las ocurrencias de ciertas propiedades:

    categoríaocurrencias
    realDonaldTrump | 12 horas | 4 minutos2
    realDonaldTrump | 13 horas | 0 minutos1

    Que finalmente podemos transformar en algo más compatible con mapas de calor:

    horas minutos01234
    1200002
    1310000

    Aquí, tenemos horas como filas, como valores únicos, así como minutos como columnas. Cada valor en las celdas es el número de ocurrencias de tweets en ese momento. Por ejemplo, aquí podemos ver 2 tweets a las 12:04 y un tweet a las 13:01. Con este enfoque, solo tenemos 24 filas (24 horas) y 60 columnas. Si imagina esta propagación visualmente, esencialmente es un mapa de calor, sin embargo, con números.

    En nuestro ejemplo, quiero entender si hay algún patrón en cómo los candidatos tuitean en diferentes momentos del día. Una forma de hacer esto es contar los tweets creados en cada hora del día y cada minuto de una hora.

    Técnicamente, tenemos 2880 categorías. Cada combinación de hour_utc, minute_utcy usernamees una categoría separada, y contamos el número de ocurrencias de tweets para cada uno de ellos.

    Esta agregación es sencilla con Pandas. La hora y el minuto de creación están disponibles en las columnas hour_utcy minute_utc. Podemos utilizar la pandas groupby()función de recoger juntos todos los tweets para cada combinación de username, hour_utcy minute_utc:

    g = df.groupby(['hour_utc','minute_utc','username'])
    

    Esto significa que sólo filas que tienen el mismo valor de hour_utc, minute_utc, usernamepueden considerarse una ocurrencia de la misma categoría.

    Ahora podemos contar el número de tweets en cada grupo aplicando la nunique()función para contar el número de correos electrónicos únicos id. Este método evita el doble recuento de los tweets duplicados que puedan estar al acecho en los datos, si no se limpian correctamente de antemano:

    tweet_cnt = g.id.nunique()
    

    Esto nos da una serie Pandas con los recuentos que necesitamos para trazar el mapa de calor:

    tweet_cnt.head()
    
    hour_utc  minute_utc  username       
    0         0           JoeBiden           26
                          realDonaldTrump     6
              1           JoeBiden           16
                          realDonaldTrump    11
              2           JoeBiden            6
    Name: id, dtype: int64
    

    Para transformar esto en la forma ancha que DataFramenecesita Seaborn, podemos usar la pivot()función Pandas .

    Para este ejemplo, será más fácil tomar un usuario a la vez y trazar un mapa de calor para cada uno de ellos por separado. Podemos poner esto en una sola figura o en figuras separadas.

    Utilice el loc[]acceso de Pandas para seleccionar el recuento de tweets de un usuario y luego aplique la pivot()función. Utiliza valores únicos del índice / columnas especificados para formar ejes del archivo DataFrame. Giraremos las horas y los minutos para que el resultado DataFrametenga una forma amplia:

    jb_tweet_cnt = tweet_cnt.loc[:,:,'JoeBiden'].reset_index().pivot(index='hour_utc', columns="minute_utc", values="id")
    

    Luego, eche un vistazo a una sección del resultado DataFrame:

    jb_tweet_cnt.iloc[:10,:9]
    

    minuto_utc012345678 hora_utc0123456101112

    26.016.06.07.04.024.02.02.09.0
    24.07.05.06.04.019.01.02.06.0
    3.03.03.0Yaya5.01.04.08.0Yaya
    3.03.03.04.05.01.03.05.04.0
    1.01.01.02.0YayaYaya1.01.01.0
    1.02.0YayaYayaYaya1.0YayaYayaYaya
    YayaYayaYayaYayaYayaYayaYayaYayaYaya
    7.02.01.0YayaYayaYayaYayaYayaYaya
    2.05.0YayaYayaYayaYayaYayaYayaYaya
    4.0Yaya1.01.01.0Yaya1.0YayaYaya

    Lidiar con los valores perdidos

    Podemos ver arriba que nuestros datos transformados contienen valores perdidos. Siempre que no haya tweets para una combinación determinada de minuto / hora, la pivot()función inserta un valor Not-a-Number ( NaN) en el DataFrame.

    Además pivot(), no crea una fila (o columna) cuando no hubo tweets durante una hora (o minuto) en particular.

    Ver más arriba, donde horas 7, 8y 9están desaparecidos.

    Esto será algo común que suceda al preprocesar datos. Es posible que falten datos, que sean de tipos o entradas extraños (sin validación), etc.

    Seaborn puede manejar bien estos datos faltantes, simplemente trazará sin ellos, saltándose las horas 7, 8 y 9. Sin embargo, nuestros mapas de calor serán más consistentes e interpretables si completamos los valores faltantes. En este caso, sabemos que los valores perdidos son realmente una cuenta de cero.

    Para completar los NaNs que ya se han insertado, use fillna()así:

    jb_tweet_cnt.fillna(0, inplace=True)
    

    Para insertar filas desaparecidos – Asegúrese de que todas las combinaciones de hora y minuto aparecen en el mapa de calor – vamos a reindex()la DataFrameque insertamos los índices desaparecidas y sus valores:

    # Ensure all hours in table
    jb_tweet_cnt = jb_tweet_cnt.reindex(range(0,24), axis=0, fill_value=0)
    # Ensure all minutes in table
    jb_tweet_cnt = jb_tweet_cnt.reindex(range(0,60), axis=1, fill_value=0).astype(int) 
    

    Excelente. Ahora podemos completar nuestra preparación de datos repitiendo los mismos pasos para los tweets de otros candidatos:

    dt_tweet_cnt = tweet_cnt.loc[:,:,'realDonaldTrump'].reset_index().pivot(index='hour_utc', columns="minute_utc", values="id")
    dt_tweet_cnt.fillna(0, inplace=True)
    dt_tweet_cnt = dt_tweet_cnt.reindex(range(0,24), axis=0, fill_value=0)
    dt_tweet_cnt = dt_tweet_cnt.reindex(range(0,60), axis=1, fill_value=0).astype(int)
    

    Creación de un mapa de calor básico con Seaborn

    Ahora que hemos preparado los datos, es fácil trazar un mapa de calor con Seaborn. Primero asegúrese de haber importado la biblioteca Seaborn:

    import seaborn as sns
    import matplotlib.pyplot as plt
    

    También importaremos el módulo PyPlot de Matplotlib, ya que Seaborn se basa en él como motor subyacente. Después de trazar gráficos con funciones de Seaborn adecuadas, siempre llamaremos plt.show()para mostrar realmente estos gráficos.

    Ahora, como es habitual con Seaborn, trazar datos es tan simple como pasar un preparado DataFramea la función que nos gustaría usar. Específicamente, usaremos la heatmap()función.

    Tracemos un mapa de calor simple de la actividad de Trump en Twitter:

    sns.heatmap(dt_tweet_cnt)
    plt.show()
    

    Y luego el de Biden:

    sns.heatmap(jb_tweet_cnt)
    plt.show()
    

    Los mapas de calor producidos con la configuración predeterminada de Seaborn se pueden utilizar de inmediato. Muestran los mismos patrones que se ven en los gráficos al principio de la guía, pero son un poco más entrecortados, más pequeños y las etiquetas de los ejes aparecen con una frecuencia impar.

    Aparte de eso, podemos ver estos patrones porque Seaborn hace mucho trabajo por nosotros, automáticamente, simplemente llamando a la heatmap()función:

    • Hizo elecciones apropiadas de paleta de colores y escala.
    • Creó una leyenda para relacionar los colores con los valores subyacentes.
    • Rotuló los ejes

    Estos valores predeterminados pueden ser lo suficientemente buenos para sus propósitos y examen inicial, como aficionado o científico de datos. Pero a menudo, producir un mapa de calor realmente efectivo requiere que personalicemos la presentación para satisfacer las necesidades de la audiencia.

    Echemos un vistazo a cómo podemos personalizar un mapa de calor de Seaborn para producir los mapas de calor que se ven al principio de la guía.

    Cómo personalizar un mapa de calor de Seaborn

    Usar el color con eficacia

    La característica definitoria de un mapa de calor es el uso del color para representar la magnitud de una cantidad subyacente.

    Es fácil cambiar los colores que usa Seaborn para dibujar el mapa de calor especificando el cmapparámetro opcional (mapa de colores ). Por ejemplo, aquí se explica cómo cambiar a la 'mako'paleta de colores:

    sns.heatmap(dt_tweet_cnt, cmap="mako")
    plt.show()
    

    Seaborn proporciona muchas paletas integradas entre las que puede elegir, pero debe tener cuidado de elegir una buena paleta para sus datos y propósito.

    Para mapas de calor que muestran datos numéricos, como el nuestro, las paletas secuenciales como las predeterminadas 'rocket'o 'mako'son buenas opciones. Esto se debe a que los colores de estas paletas se han elegido para que sean perceptualmente uniformes. Esto significa que la diferencia que percibimos entre dos colores con nuestros ojos es proporcional a la diferencia entre los valores subyacentes.

    El resultado es que al echar un vistazo al mapa podemos tener una idea inmediata de la distribución de valores en los datos.

    Un contraejemplo demuestra los beneficios de una paleta perceptualmente uniforme y las trampas de una mala elección de paleta. Aquí está el mismo mapa de calor dibujado con la tab10paleta:

    sns.heatmap(dt_tweet_cnt, cmap="tab10")
    plt.show()
    

    Esta paleta es una mala elección para nuestro ejemplo porque ahora tenemos que trabajar muy duro para comprender la relación entre diferentes colores. ¡Ha oscurecido en gran medida los patrones que antes eran obvios!

    Esto se debe a que la tab10paleta utiliza cambios de tono para facilitar la distinción entre categorías. Puede ser una buena opción si los valores de su mapa de calor fueran categóricos.

    Si está interesado en los valores altos y bajos de sus datos, podría considerar usar una paleta divergente como coolwarmo icefireque es un esquema uniforme que resalta ambos extremos.

    Para obtener más información sobre la selección de paletas de colores, la documentación de Seaborn tiene una guía útil .

    Controle el efecto de distorsión de los valores atípicos

    Los valores atípicos en los datos pueden causar problemas al trazar mapas de calor. De forma predeterminada, Seaborn establece los límites de la escala de colores al valor mínimo y máximo en los datos.

    Esto significa que valores extremadamente grandes (o pequeños) en los datos pueden hacer que los detalles se oculten. Cuanto más extremos sean los valores atípicos, más lejos estamos de un paso de coloración uniforme. Hemos visto el efecto que esto puede tener con los diferentes mapas de colores.

    Por ejemplo, si agregamos un valor de valor atípico extremo, como 400 ocurrencias de tweets en un solo minuto, ese valor atípico cambiará la extensión del color y lo distorsionará significativamente:

    Una forma de manejar valores extremos sin tener que eliminarlos del conjunto de datos es usar el robustparámetro opcional . Si se establece robusten True, Seaborn establezca los límites de la escala de color en los valores de los percentiles 2 y 98 de los datos, en lugar de los valores máximo y mínimo. Esto, en la gran mayoría de los casos, normalizará la dispersión del color en un estado mucho más utilizable.

    Tenga en cuenta que en nuestro ejemplo, esto varió la ocurrencia / propagación del color desde 0..16, a diferencia 0..40de antes. Esto no es ideal, pero es una solución rápida y fácil para valores extremos.

    Eso puede traer de vuelta los detalles como muestra el ejemplo de la derecha. Tenga en cuenta que el punto de valor extremo todavía está presente en el gráfico; los valores superiores o inferiores a los límites de la escala de colores se recortan a los colores de los extremos de la escala.

    También es posible establecer manualmente los límites de la escala de colores configurando los valores de los parámetros vminy vmax. Puede ser muy útil si planea tener dos mapas de calor uno al lado del otro y desea garantizar la misma escala de colores para cada uno:

    sns.heatmap(tmp, vmin=0, vmax=40)
    plt.show()
    

    Composición: ordenación de las relaciones entre ejes y superficies

    En nuestro ejemplo los valores que componen los ejes de nuestro mapa de calor, las horas y los minutos, tienen un orden natural. Es importante tener en cuenta que estos son valores discretos, no continuos y que se pueden reorganizar para ayudar a los patrones de superficie en los datos.

    Por ejemplo, en lugar de tener los minutos en el orden ascendente normal, podríamos optar por ordenarlos en función de qué minuto tiene la mayor cantidad de tweets:

    Esto proporciona una nueva presentación alternativa de los datos del recuento de tweets. Desde el primer mapa de calor, podemos ver que Biden prefiere tuitear en las marcas trimestre ( 30, 45, 0y 15más allá de la hora), de forma similar a cómo ciertos individuos puesto su volumen del televisor en incrementos de 5, o cuántas personas tienden a «espera para el el momento adecuado «para comenzar a realizar una tarea, generalmente en un número redondo o en un cuarto.

    Por otro lado, no parece haber un minuto favorable en el segundo mapa de calor. Hay una distribución bastante constante a lo largo de todos los minutos de la hora y no hay muchos patrones que se puedan observar.

    En otros contextos, la ordenación y / o agrupación cuidadosa de las variables categóricas que componen los ejes del mapa de calor puede ser útil para resaltar patrones en los datos y aumentar la densidad de información del gráfico.

    Agregar anotaciones de valor

    Una desventaja de los mapas de calor es que es difícil hacer comparaciones directas entre valores. Un gráfico de barras o de líneas es una forma mucho más sencilla de hacer esto.

    Sin embargo, es posible aliviar este problema agregando anotaciones al mapa de calor para mostrar los valores subyacentes. Esto se hace fácilmente en Seaborn estableciendo el annotparámetro en True, así:

    sns.heatmap(jb_tweet_cnt.iloc[14:23,25:35], annot=True)
    plt.show()
    

    Hemos recortado los datos en un conjunto más pequeño para que sea más fácil ver y comparar algunos de estos contenedores. Aquí, cada contenedor ahora está anotado con los valores subyacentes, lo que hace que sea mucho más fácil compararlos. Aunque no es tan natural e intuitivo como un gráfico de líneas o un gráfico de barras, sigue siendo útil.

    Trazar estos valores en todo el mapa de calor que tenemos no sería práctico, ya que los números serían demasiado pequeños para leerlos.

    Un compromiso útil puede ser agregar anotaciones solo para ciertos valores interesantes. En el siguiente ejemplo, agreguemos una anotación solo para el valor máximo.

    Esto se hace creando un conjunto de etiquetas de anotación que se pueden pasar a la heatmap()función de Seaborn a través del annotparámetro. El annot_kwsparámetro también se puede utilizar para controlar aspectos de la etiqueta como el tamaño de la fuente utilizada:

    # Create data labels, using blank string if under threshold value
    M = jb_tweet_cnt.iloc[14:23,25:35].values.max()
    labels = jb_tweet_cnt.iloc[14:23,25:35].applymap(lambda v: str(v) if v == M else '')
    
    # Pass the labels to heatmap function
    sns.heatmap(jb_tweet_cnt.iloc[14:23,25:35], annot=labels, annot_kws={'fontsize':16}, fmt="")
    
    plt.show()
    

    Puede ser creativo al definir conjuntos de etiquetas personalizados. La única restricción es que los datos que pasa para las etiquetas deben tener el mismo tamaño que los datos que está trazando. Además, si sus etiquetas son cadenas, debe pasar el fmt=""parámetro para evitar que Seaborn interprete sus etiquetas como números.

    Cuadrículas y cuadrados

    De vez en cuando, es útil recordarle a su audiencia que un mapa de calor se basa en contenedores de cantidades discretas. Con algunos conjuntos de datos, el color entre dos contenedores puede ser muy similar, creando una textura similar a un degradado que hace que sea más difícil discernir entre valores específicos. El parámetro linewidthy linecolorse puede utilizar para agregar líneas de cuadrícula al mapa de calor.

    De manera similar, el parámetro squarepuede usarse para forzar que la relación de aspecto de los cuadrados sea verdadera. Tenga en cuenta que no necesita usar cuadrados para los contenedores.

    Agreguemos una línea blanca delgada entre cada contenedor para enfatizar que son entradas separadas:

    sns.heatmap(jb_tweet_cnt.iloc[14:23,25:35], linewidth=1, linecolor="w", square=True)
    
    plt.show()
    

    En cada uno de estos casos, depende de su juicio si estos cambios estéticos promueven los objetivos de su visualización o no.

    Mapas de calor categóricos en Seaborn

    Hay ocasiones en las que es útil simplificar un mapa de calor colocando datos numéricos en categorías. Por ejemplo podríamos bucket los datos de recuento tuit en sólo tres categorías 'high', 'medium'y 'low', en lugar de un rango numérico como 0..40.

    Desafortunadamente, en el momento de escribir este artículo, Seaborn no tiene la capacidad incorporada para producir mapas de calor para datos categóricos como este, ya que espera una entrada numérica. Aquí hay un fragmento de código que muestra que es posible «falsificarlo» con un poco de pirateo de paleta y barra de colores.

    Aunque esta es una circunstancia en la que es posible que desee considerar el mérito de otros paquetes de visualización que tienen estas características integradas.

    Usaremos la ayuda de Matplotlib, el motor subyacente debajo de Seaborn, ya que tiene muchas opciones de personalización de bajo nivel y tenemos acceso completo a él. Aquí, podemos «piratear» la leyenda de la derecha para mostrar los valores que nos gustaría:

    import matplotlib.pyplot as plt
    
    fig,ax = plt.subplots(1,1,figsize=(18,8))
    my_colors=[(0.2,0.3,0.3),(0.4,0.5,0.4),(0.1,0.7,0),(0.1,0.7,0)]
    
    sns.heatmap(dt_tweet_cnt, cmap=my_colors, square=True, linewidth=0.1, linecolor=(0.1,0.2,0.2), ax=ax)
    
    colorbar = ax.collections[0].colorbar
    M=dt_tweet_cnt.max().max()
    colorbar.set_ticks([1/8*M,3/8*M,6/8*M])
    colorbar.set_ticklabels(['low','med','high'])
    
    plt.show()
    

    Preparación de mapas de calor para la presentación

    Un par de últimos pasos para dar los toques finales a su mapa de calor.

    Uso del contexto de Seaborn para controlar la apariencia

    La set_context()función proporciona una forma útil de controlar algunos de los elementos del gráfico sin cambiar su estilo general. Por ejemplo, puede ser una forma conveniente de personalizar tamaños de fuente y familias.

    Hay varios contextos preestablecidos disponibles :

    sns.set_context("notebook", font_scale=1.75, rc={"lines.linewidth": 2.5, 'font.family':'Helvetica'})
    

    Uso de subparcelas para controlar el diseño de mapas de calor

    El último paso para crear nuestro mapa de calor de recuento de tweets es colocar los dos gráficos uno al lado del otro en una sola figura para que sea fácil hacer comparaciones entre ellos.

    Podemos usar la subplot()función de matplotlib.pyplotpara controlar el diseño de mapas de calor en Seaborn. Esto le dará el máximo control sobre el gráfico final y permitirá una fácil exportación de la imagen.

    Crear subtramas usando Matplotlib es tan fácil como definir su forma (2 subtramas en 1 columna en nuestro caso):

    import matplotlib.pyplot as plt
    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12,12))
    sns.heatmap(jb_tweet_cnt, ax=ax1)
    sns.heatmap(dt_tweet_cnt, ax=ax2)
    
    plt.show()
    

    Esto es esencialmente, aunque carece del estilo que hemos visto al principio. Reunamos muchas de las personalizaciones que hemos visto en la guía para producir nuestro gráfico final y exportarlo .pngpara compartirlo:

    import matplotlib.pyplot as plt
    fig, ax = plt.subplots(2, 1, figsize=(24,12))
    
    for i,d in enumerate([jb_tweet_cnt,dt_tweet_cnt]):
       
        labels = d.applymap(lambda v: str(v) if v == d.values.max() else '')
        sns.heatmap(d,
                    cmap="viridis",  # Choose a squential colormap
                    annot=jb_labels, # Label the maximum value
                    annot_kws={'fontsize':11},  # Reduce size of label to fit
                    fmt="",          # Interpret labels as strings
                    square=True,     # Force square cells
                    vmax=40,         # Ensure same 
                    vmin=0,          # color scale
                    linewidth=0.01,  # Add gridlines
                    linecolor="#222",# Adjust gridline color
                    ax=ax[i],        # Arrange in subplot
                   )
        
    ax[0].set_title('@JoeBiden')
    ax[1].set_title('@realDonaldTrump')
    ax[0].set_ylabel('Hour of Day')
    ax[1].set_ylabel('Hour of Day')
    ax[0].set_xlabel('')
    ax[1].set_xlabel('Minute of Hour')
    plt.tight_layout()
    plt.savefig('final.png', dpi=120)
    

    Conclusión

    En esta guía, analizamos los mapas de calor y cómo crearlos con Python y la biblioteca de visualización de Seaborn.

    La fuerza de los mapas de calor está en la forma en que usan el color para transmitir información, en otras palabras, hace que sea fácil para cualquiera ver patrones amplios de un vistazo.

    Hemos visto cómo para hacer esto tenemos que hacer selecciones cuidadosas de paleta de colores y escala. También hemos visto que hay varias opciones disponibles para personalizar un mapa de calor usando Seaborn con el fin de enfatizar aspectos particulares del gráfico. Estos incluyen anotaciones, agrupación y ordenación de ejes categóricos y diseño.

    Como siempre, se requiere un juicio editorial por parte del Visualizador de datos para elegir las personalizaciones más apropiadas para el contexto de la visualización.

    Hay muchas variantes del mapa de calor que puede interesarle estudiar, incluidos mapas de calor radiales, diagramas de mosaico o gráficos matriciales.

     

    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *