Visuales de Python en Power BI

Entre sus ventajas, Power BI es una herramienta de visualización extremadamente flexible. La vez pasada vimos un poco sobre la transformación de datos con Python. Hoy toca explorar un poco más allá con los visuales de Python.

Transformar datos con Python es excelente, ya que podemos crear cálculos intrincados más efectivos y cargarlos directamente desde un marco de datos Pandas a nuestras tablas de Power BI. Esto viene con algunas limitantes, siendo la principal con respecto a cuando el código es ejecutado.

Cuando creamos una transformación, estamos haciendo cambios en todo el conjunto de datos. Eso es bueno en muchos casos, como limpiar, arreglar, añadir cálculos previos, por nombrar algunos.

El problema viene cuando tenemos muchas posibilidades o resultados. Si, por ejemplo, queremos que el usuario vea un número que venga de diferentes combinaciones de categorías, necesitaríamos un resultado por cada posibilidad, lo cual nos representaría una cantidad absurda.

Es aquí donde los visuales de Python nos vienen bien, ya que nos dejan hacer los cálculos a tiempo para que podamos trabajar con datos filtrados sin tener que replicar la misma medida por cada resultado posible, por lo que hoy vamos a recorrer los puntos básicos para crear un visual de Python en Power BI usando Pandas, Spicy y Matplotlib.

Para demostrarlo con un ejemplo, vamos a explorar algunas enfermedades infecciosas mientras implementamos un algoritmo relativamente simple para modelar cómo es que se propagan.

SIR, que son las siglas para Susceptible, Infectado y Recuperado. Ahora miremos el código:

import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as plt
# N - Population
# I0 - Initial number of infected people
# R0 - Initial number of recovered people
# S0 - Initial number of suceptible people
# beta - Contact rate
# gamma = Recovery rate (1/ days to recover)
# t - Time in days (list with the days to be calculated)

N = 1000
I0, R0 = 1, 0
S0 = N - I0 - R0
beta, gamma = 0.2, 1./10
t = np.linspace(0, 160, 160)# SIR model
def deriv(y, t, N, beta, gamma):
S, I, R = y
dSdt = -beta * S * I / N
dIdt = beta * S * I / N - gamma * I
dRdt = gamma * I
return dSdt, dIdt, dRdt# vector with starting conditions
y0 = S0, I0, R0# over time(t)
ret = odeint(deriv, y0, t, args=(N, beta, gamma))
S, I, R = ret.T

Tenemos siete variables diferentes:

• N
• I0
• R0
• S0
• beta
• gamma
• t

La ecuación SIR, un vector con las condiciones de inicio para el modelo y una llamada desde el método «odeint» a la clase Scipy «integrate». Lo que nos importa más integrar a Power BI son las variables, por lo que nuestro objetivo es reemplazar esas variables con referencias a las tablas.

TABLAS DE POWER BI

Podemos ir directo a Power BI y crear una tabla por cada variable que queremos reemplazar. Cada tabla debe contener una columna con los posibles valores para la variable. Para propósitos de este ejemplo, voy a usar una lista simple, pero podemos generar estos valores de manera sistemática o usar valores de un conjunto de datos que ya tengamos.

Ahora podemos crear algunos separadores para seleccionar desde esos valores.

Con esto todos los elementos están en su lugar. Cuando añadimos un visual de Python a nuestro reporte y añadimos las variables que hemos creado, recibiremos un marco de datos con los valores.

Ahora probemos nuestra visualización en Jupyter antes de poder llevarla a Power BI. Primero crearemos un marco de datos para simular cómo vamos a recibir estos datos. Podemos llamarlo «conjunto de datos», tal y como Power BI hace.

import pandas
dataset = pandas.DataFrame([{'Population':10,
                             'I0':1,
                             'Gamma':0.06,
                             'Beta':0.25,
                             't':150}])
dataset

Cuando reemplazamos las variables con referencias al marco de datos, obtendremos esto:

import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as plt

N = dataset['Pop_total'].values[0]
I0, R0 = dataset['Ini_infected_pop'].values[0], 0
S0 = N - I0 - R0
beta, gamma = dataset['Recovery_Rate_beta'].values[0], dataset['Contact_Rate_Gamma'].values[0]
t = np.linspace(0, dataset['Days_To_Simulate'].values[0], dataset['Days_To_Simulate'].values[0])

# SIR model
def deriv(y, t, N, beta, gamma):
    S, I, R = y
    dSdt = -beta * S * I / N
    dIdt = beta * S * I / N - gamma * I
    dRdt = gamma * I
    return dSdt, dIdt, dRdt

# vector with starting conditions
y0 = S0, I0, R0# Over time (t)
ret = odeint(deriv, y0, t, args=(N, beta, gamma))
S, I, R = ret.T

TRAZANDO CON MATPLOTLIB

Ahora podemos trazar cada variable simulada (S, I y R) en tiempo real.

 # labels, figure, and axis
labels = ['Susceptible', 'Infected', 'Recovered with immunity']
fig, ax = plt.subplots(1, figsize=(16,8), facecolor="#5E5E5E")
ax.set_facecolor("#5E5E5E")

 # plot
plt.plot(t, S/1000, '#26D4F9', alpha=0.5, lw=2)
plt.plot(t, I/1000, '#F0F926', alpha=0.8, lw=2)
plt.plot(t, R/1000, '#26F988', alpha=0.8, lw=2)

# legend
legend = ax.legend(labels,
                   ncol=3,
                   fontsize = 12,
                   bbox_to_anchor=(1, 1.05))
legend.get_frame().set_alpha(0)

for text in legend.get_texts():
    plt.setp(text, color = 'w')
# axis labels, limits, and ticks
    ax.set_xlabel('Days', c='w', fontsize=14)
    ax.set_ylabel('1000s of People', c='w', fontsize=14)
    plt.xticks(c='w', fontsize=12)
    plt.yticks(c='w', fontsize=12)
    ax.set_ylim(0,)# grid and spines
    ax.grid(axis='y', c='grey', lw=1, ls='--', alpha=0.8)
    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)
    plt.title("S.I.R. Model", c='w', fontsize=16, loc='left')
plt.show()

IMPLEMENTANDO

Si todo ha salido bien, entonces ya podemos llevarlo a Power BI.

Como ya añadimos el visual, solo necesitamos copiar y pegar este código, asegurarnos que los nombres de nuestras variables son los mismos que los que usamos en las referencias del conjunto de datos, y estará listo.

Ahora podemos elegir los valores de cada variable con los separadores y la gráfica se actualizará de manera dinámica, calculando y mostrando la simulación en tiempo real.

Como nota final, podemos agregar que por usar los visuales de Python podemos perder mucha de la interactividad de Power BI, tal como darle click a valores para resaltarlos en otros gráficos o tips de herramientas. Existen otras funciones que Matplotlib provee que de momento no se pudieron implementar en Power BI, en su mayoría respecto a la interactividad y animación.