5 formas rápidas de visualizar datos en Phyton

Python_logo

La visualización de datos es un elemento básico en la labor de un científico de datos. En las primeras etapas de un proyecto, a menudo realizará un análisis de datos (EDA) para obtener algunas perspectivas de los datos tratados. La creación de visualizaciones de datos realmente ayuda en gran medida a que las cosas sean más claras y fáciles de entender, especialmente con datasets más grandes y de alta dimensión.

Además Hacia el final de un proyecto, es importante ser capaz de presentar los resultados finales de una manera clara, concisa, y convincente para el público al que se dirige, que a menudo son clientes no técnicos, y pueden no entender lo que se les presenta fácilmente.

Kernel es una popular librería de Python que podemos utilizar para crear las visualizaciones de datos con bastante facilidad. Sin embargo, configurar los datos, parámetros, figuras y trazados puede resultar bastante complicado y tedioso de hacer cada vez que realizamos un nuevo proyecto. En este post, vamos a mirar 6 visualizaciones de datos y escribir algunas funciones rápidas y fáciles para estos con kernel de Python.

(Mientras tanto, aquí hay un gran gráfico para seleccionar la visualización correcta para el trabajo!)

data_show

Scatter Plots


Las Scatter Plots son excelentes para mostrar la relación entre dos variables ya que se puede ver directamente la distribución de datos RAW. También puedemos ver esta relación para diferentes grupos de datos por colores codificando los grupos como se ve en la primera figura de abajo.

plots_scarted

data_show2

Ahora el código.

Primero importamos el pyplot de kernel con el alias “PLT”. Pasamos los datos del eje x y del eje y a la función. Luego los pasamos a AX Scatter () para poder trazar la trama de dispersión. También podemos establecer el tamaño que deseamos del punto, su color y  transparencia. Incluso podemos establecer el eje Y para tener una escala logarítmica. El título y las etiquetas del eje se establecen a continuación específicamente para la figura.

import matplotlib.pyplot as plt
import numpy as np

def scatterplot(x_data, y_data, x_label="", y_label="", title="", color = "r", yscale_log=False):

    # Create the plot object
    _, ax = plt.subplots()

    # Plot the data, set the size (s), color and transparency (alpha)
    # of the points
    ax.scatter(x_data, y_data, s = 10, color = color, alpha = 0.75)

    if yscale_log == True:
        ax.set_yscale('log')

    # Label the axes and provide a title
    ax.set_title(title)
    ax.set_xlabel(x_label)
    ax.set_ylabel(y_label)

Line Plots


Las Line Plots se utilizan mejor cuando se puede ver claramente que una variable varía enormemente con otra, es decir, que tienen una alta covarianza. Echemos un vistazo a la figura de abajo para entenderlo mejo. En esta podemos ver claramente que hay una gran cantidad de variación en los porcentajes. Trazar estos con una trama de dispersión generaria una imagen muy abarrotada y bastante desordenada, por lo que seria difícil de entender realmente lo que está pasando. Las Line Plots son perfectas para estas situaciones, ya que básicamente nos dan un resumen rápido de la covarianza de las dos variables (porcentaje y tiempo). Una vez más, también podemos utilizar la agrupación por codificación con colore.

line_plots

 

Y aquí está el código de Line Plots. Veréis que es bastante similar a la dispersión de arriba y con tan sólo algunas variaciones menores en las variables.

def histogram(data, n_bins, cumulative=False, x_label = "", y_label = "", title = ""):
    _, ax = plt.subplots()
    ax.hist(data, n_bins = n_bins, cumulative = cumulative, color = '#539caf')
    ax.set_ylabel(y_label)
    ax.set_xlabel(x_label)
    ax.set_title(title)

Histograms


Los histogramas son útiles para ver (o realmente descubrir) la distribución de los puntos de datos. Si observas el histograma de aquí abajo, donde trazamos el histograma de la frecuencia vs IQ,  podemos ver claramente la concentración hacia el centro y cuál es la mediana. También podemos ver que sigue una distribución de Gauss. El uso de las barras (en lugar de los puntos de dispersión, por ejemplo) realmente nos da una visualización clara de la diferencia relativa entre la frecuencia de cada bin. El uso de bins (Discrete) realmente nos ayuda a ver el “panorama más grande”. En cambio si usamos todos los puntos de datos sin bins discretos, habría mucho ruido en la visualización, lo que dificultaría ver lo que realmente está sucediendo.

histo1

A continuación mostramos el código del histograma en kernel. Hay dos parámetros a tener en cuenta.

  • En primer lugar, los parámetros n_bins controlan la cantidad de bins discretos que queremos para nuestro histograma. Más bins nos dará información más fina, pero también puede introducir el ruido y nos llevará lejos de la imagen más grande; por otro lado, menos bins nos da una visión más “birds eye view” y un panorama más amplio de lo que está pasando sin los detalles más finos.
  • En segundo lugar, el parámetro cumulative es un booleano que nos permite seleccionar si nuestro histograma es acumulativo o no. Esto es básicamente la selección de la función de densidad de probabilidad (pdf) o la función de densidad acumulativa (CDF).

histo2

Imaginemos que queremos comparar la distribución de dos variables en nuestros datos. Uno podría pensar que tendría que hacer dos histogramas separados y ponerlos de lado para compararlos. Pero, en realidad hay una mejor manera: podemos superponer los histogramas con una transparencia variable!. Fíjate la figura de abajo. La distribución uniforme está establecida para tener una transparencia de 0,5 para que podamos ver lo que hay detrás. Esto permite el uso de ver directamente las dos distribuciones en la misma figura.

histo4

Es importante destacar que hay algunas cosas a configurar en el código para los histogramas superpuestos. Primero, establecemos el rango horizontal para acomodar ambas distribuciones variables. Según esta gama y el número deseado de compartimientos podemos realmente procesar la anchura de cada compartimiento. Finalmente, trazamos los dos histogramas en la misma parcela, siendo uno de ellos ligeramente más transparente, para que sean fáciles de entender.

# Overlay 2 histograms to compare them
def overlaid_histogram(data1, data2, n_bins = 0, data1_name="", data1_color="#539caf", data2_name="", data2_color="#7663b0", x_label="", y_label="", title=""):
    # Set the bounds for the bins so that the two distributions are fairly compared
    max_nbins = 10
    data_range = [min(min(data1), min(data2)), max(max(data1), max(data2))]
    binwidth = (data_range[1] - data_range[0]) / max_nbins


    if n_bins == 0
    bins = np.arange(data_range[0], data_range[1] + binwidth, binwidth)
    else: 
    bins = n_bins

    # Create the plot
    _, ax = plt.subplots()
    ax.hist(data1, bins = bins, color = data1_color, alpha = 1, label = data1_name)
    ax.hist(data2, bins = bins, color = data2_color, alpha = 0.75, label = data2_name)
    ax.set_ylabel(y_label)
    ax.set_xlabel(x_label)
    ax.set_title(title)
    ax.legend(loc = 'best')

Bar Plots


Las Bar Plots son más eficaces cuando se trata de visualizar datos categóricos que tienen pocas (probablemente < 10) categorías. Si tenemos demasiadas categorías entonces las barras estarán muy abarrotadas en la imagen y por lo tanto difíciles de entender. Con las Bar Plots podremos ver fácilmente la diferencia entre las categorías basadas en el tamaño de la barra (es decir magnitud).

Hay 3 tipos diferentes de Bar Plots: regular, agrupado y apilado.

Regular

En la función barplot(), x_data representa los ticker en el eje “x” y y_data representa la altura de la barra en el eje y. La barra de error es una línea adicional centrada en cada barra que se puede dibujar para mostrar la desviación estándar.

regular_bar_plots

Agrupado

Las Bar Plots agrupadas nos permiten comparar múltiples variables categóricas. Fíjate en la segunda parcela de la barra de abajo. La primera variable que estamos comparando es ¿cómo las puntuaciones varían según el grupo (grupos G1, G2,… etc)?. También estamos comparando los géneros con los códigos de color. Al examinar el código, la variable y_data_list es ahora en realidad una lista de listas, donde cada sublista representa un grupo diferente. Luego hacemos un bucle a través de cada grupo, y para cada grupo dibujamos la barra para cada tick en el eje x; cada grupo también está codificado con colores.

grouped_bar_plots

Apilado

Los diagramas apilados son grandes y facilitan la visualización de categorías de diversas variables. En la figura del diagrama de barras apiladas a continuación estamos comparando la carga del servidor día a día. Con las apiladas codificadas en color, podemos ver y comprender fácilmente qué servidores estan trabajando más y cómo las cargas se comparan con los otros servidores. El código para esto sigue el mismo estilo que la trama de la barra agrupada. Hacemos un bucle a través de cada grupo, excepto que esta vez dibujamos las barras nuevas en la parte superior en lugar de a su lado.

stacked_bar_plots

def barplot(x_data, y_data, error_data, x_label="", y_label="", title=""):
    _, ax = plt.subplots()
    # Draw bars, position them in the center of the tick mark on the x-axis
    ax.bar(x_data, y_data, color = '#539caf', align = 'center')
    # Draw error bars to show standard deviation, set ls to 'none'
    # to remove line between points
    ax.errorbar(x_data, y_data, yerr = error_data, color = '#297083', ls = 'none', lw = 2, capthick = 2)
    ax.set_ylabel(y_label)
    ax.set_xlabel(x_label)
    ax.set_title(title)

def stackedbarplot(x_data, y_data_list, colors, y_data_names="", x_label="", y_label="", title=""):
    _, ax = plt.subplots()
    # Draw bars, one category at a time
    for i in range(0, len(y_data_list)):
        if i == 0:
            ax.bar(x_data, y_data_list[i], color = colors[i], align = 'center', label = y_data_names[i])
        else:
            # For each category after the first, the bottom of the
            # bar will be the top of the last category
            ax.bar(x_data, y_data_list[i], color = colors[i], bottom = y_data_list[i - 1], align = 'center', label = y_data_names[i])
    ax.set_ylabel(y_label)
    ax.set_xlabel(x_label)
    ax.set_title(title)
    ax.legend(loc = 'upper right')

def groupedbarplot(x_data, y_data_list, colors, y_data_names="", x_label="", y_label="", title=""):
    _, ax = plt.subplots()
    # Total width for all bars at one x location
    total_width = 0.8
    # Width of each individual bar
    ind_width = total_width / len(y_data_list)
    # This centers each cluster of bars about the x tick mark
    alteration = np.arange(-(total_width/2), total_width/2, ind_width)

    # Draw bars, one category at a time
    for i in range(0, len(y_data_list)):
        # Move the bar to the right on the x-axis so it doesn't
        # overlap with previously drawn ones
        ax.bar(x_data + alteration[i], y_data_list[i], color = colors[i], label = y_data_names[i], width = ind_width)
    ax.set_ylabel(y_label)
    ax.set_xlabel(x_label)
    ax.set_title(title)
    ax.legend(loc = 'upper right')

 

Box Plots


Hemos visto como los histogramas son idóneos para visualizar la distribución de variables. Pero ¿y si necesitamos más información? ¿Queremos una visión más clara de la desviación estándar? ¿La mediana es muy diferente de la media y por lo tanto tenemos muchos valores atípicos? ¿Qué pasa si hay tanto para sesgar y muchos de los valores se concentran a un lado?

Ahora es cuando debemos conocer los BoxPlots. Estos nos dan toda la información anterior. La parte inferior y la parte superior de la caja son siempre el primer y tercer cuarto (es decir, suponen el 25% y 75% de los datos), y la banda dentro de la caja es siempre el segundo cuarto (o sea, la mediana). Los whiskers (es decir, las líneas punteadas con las barras en el extremo) se salen de la caja para mostrar el rango de los datos.

Dado que la trama de la caja se dibuja para cada grupo/variable es bastante fácil de configurar. El x_data es una lista de los grupos/variables. La función kernel boxplot()hace una trama de caja para cada columna del y_data o cada vector en secuencia y_data; así cada valor en x_data corresponde a una columna/a un vector en y_data. Todo lo que tenemos que poner entonces es la estética de la trama.

 

boxplots1

def boxplot(x_data, y_data, base_color="#539caf", median_color="#297083", x_label="", y_label="", title=""):
    _, ax = plt.subplots()

    # Draw boxplots, specifying desired style
    ax.boxplot(y_data
               # patch_artist must be True to control box fill
               , patch_artist = True
               # Properties of median line
               , medianprops = {'color': median_color}
               # Properties of box
               , boxprops = {'color': base_color, 'facecolor': base_color}
               # Properties of whiskers
               , whiskerprops = {'color': base_color}
               # Properties of whisker caps
               , capprops = {'color': base_color})

    # By default, the tick label starts at 1 and increments by 1 for
    # each box drawn. This sets the labels to the ones we want
    ax.set_xticklabels(x_data)
    ax.set_ylabel(y_label)
    ax.set_xlabel(x_label)
    ax.set_title(title)

Conclusión


Encontramos 5 visualizaciones de datos rápidas y fáciles si usamos kernel.

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s