Publicando funções em Python e modelo de previsão Prophet no Tableau com TabPy

Ferramentas do TabPy

TabPy Tools é um pacote Python para publicar e gerenciar funções em Python no servidor TabPy. 

Vamos explorar a fundo as funcionalidades do TabPy Tools.

Conectando ao TabPy

A função de cliente permite conectar a API do Python ao servidor TabPy usando URL e PORTA. 

rom tabpy.tabpy_tools.client import Client

client = Client('http://localhost:9004/')

Podemos usar o objeto "client" para definir autenticação e gerenciar funções em Python no servidor. 

Autenticação

Você pode definir seu nome de usuário e senha usando a função "set_credentials". É necessário configurar as credenciais para publicar um modelo no servidor. 

Observação: execute esta função apenas se você tiver habilitado a autenticação no servidor TabPy. Leia a documentação de configuração do servidor para saber mais.  

client.set_credentials('username', 'password')

Publicando uma função

Crie uma função e publique usando a função `client.deploy()`. São necessários três argumentos: nome da função, função Python e descrição. 

A função addition soma dois campos de dados e retorna a lista. Depois, a função "add" será acessada no Tableau.

client.deploy('add', addition, 'Adds two numbers x and y')

Publicando um modelo

Quando você treina um modelo de machine learning e publica a função de inferência do modelo, o Tableau salva automaticamente o modelo e a definição das funções usando o cloudpickle. Isso permanece na memória do servidor para oferecer um tempo de resposta mais rápido. 

Em outras palavras, você não precisa re-treinar seu modelo sempre que algo mudar no Tableau. Vamos ver mais sobre publicação de modelos nas próximas seções. 

Removendo endpoints

Para remover uma função ou modelo, use a função `remove`. Basta informar o nome da função. 

client.remove('add')

>>> Para recursos mais avançados, confira o repositório TabPy/tabpy no GitHub.

Publicando uma função Python usando a IDE

Assim como na parte um, vamos criar uma função do coeficiente de correlação de Pearson. Em vez de escrever a função no Tableau, vamos publicá-la no servidor usando a API do Python e depois acessá-la por meio de um cálculo no Tableau.

Nesta seção, vamos usar o dataset Sales Store Product do Kaggle para calcular a correlação entre os campos de dados de vendas e lucro. 

Kaggle Dataset Sales Store Product

Antes de escrever o código em Python, verifique se você tem a versão mais recente do pacote TabPy.

pip install -U tabpy

Execute o servidor localmente usando um terminal.

tabpy

Cliente TabPy 

Se você já tem familiaridade com Python, esta parte é bem simples. Você pode aprender tudo sobre funções em Python no curso de introdução ao Python.

1. Vamos importar o Client do tabpy_tools e o NumPy para os cálculos. 
2. Conectar ao servidor TabPy usando URL e PORTA.
3. Criar pearson_correlation_coefficient() que recebe x e y e retorna o coeficiente de correlação em uma única coluna. 
4. Usar a função client.deploy() para publicar a função "pcc". Ela requer três argumentos: nome, função e descrição.  

from tabpy.tabpy_tools.client import Client
import numpy as np


client = Client('http://localhost:9004/')


def pearson_correlation_coefficient(x,y):
    return np.corrcoef(x,y)[0,1]


client.deploy('pcc', pearson_correlation_coefficient, 'correlation coefficient is extracted of x and y')

Consulta TabPy 

Agora vamos invocar essa função no Tableau usando tabpy.query(). São necessários os nomes da função Python e os placeholders de argumentos, como _arg1 e _arg2. 

1. Dentro do SCRIPT_REAL, adicione o script de consulta e agregue os campos de dados. 
2. O script de consulta começa com return e termina com [‘response’] para extrair os resultados do JSON.
3. Defina o cálculo de tabela padrão para o campo de dados Customer Name.
4. Apply e clique em OK.

Campo calculado do coeficiente de correlação de Pearson

Você pode revisar a primeira parte do tutorial para entender o script do Tableau. 

SCRIPT_REAL("return tabpy.query('pcc',_arg1, _arg2)['response']",
SUM([Sales]),SUM([Profit]))

Visualização de dados 

Agora vamos criar uma visualização exibindo a correlação categorizada por categoria de produto e segmentação de clientes.

1. Arraste e solte Customer Name em Detail e Ship Mode em Color no painel Marks. 
2. Arraste e solte Customer Segment e pcc (campo calculado de correlação) na prateleira Columns. 
3. Arraste e solte Product Category na prateleira Rows.

Exibindo gráfico de barras do coeficiente de correlação 

Na maioria dos casos, o setor Corporate apresenta alta correlação entre vendas e lucro. No geral, você pode usar coeficientes de correlação e tomar decisões orientadas por dados para aumentar o lucro da empresa. 

Leia nosso tutorial Python details on correlation para conhecer outros coeficientes de correlação, como calcular correlação em Python e a relação entre correlação e causalidade. 

Publicando o modelo Prophet no Tableau 

Nesta seção, vamos publicar o modelo de previsão Facebook Prophet e aprender a modificar campos de data. Vamos treinar o modelo de séries temporais com os Apple Stock Prices de 2015 a 2020. 

Kaggle Dataset Apple Stock Prices (2015-2020)

Antes de escrever os scripts e criar a visualização de previsão no Tableau, precisamos testar o código em Python e avaliar o modelo de previsão no Jupyter Notebook. 

Facebook Prophet 

O Facebook Prophet é uma biblioteca open source para previsão automática de séries temporais univariadas. Ele funciona melhor com sazonalidade anual, semanal e diária. 

Por que usar o Prophet? 

Ele lida bem com dados ausentes, mudanças de tendência e outliers.  

Instalando o Prophet

Você pode instalar o pacote Prophet para Python com o comando abaixo no terminal. 

pip install pystan==2.19.1.1
pip install prophet

Ou, se você usa o ambiente Python do Anaconda, use o comando abaixo. 

conda install -c conda-forge prophet

Inicialização do projeto 

1. Vamos começar importando o pandas para ingestão e manipulação de dados e o Prophet para treinar e avaliar modelos de previsão. 
2. Ler o arquivo do dataset da Apple (AAPL.csv) usando a função read_csv do pandas.
3. Definir X com as colunas date e high.   
4. Exibir o shape do dataframe e visualizar o gráfico de linha da série temporal da coluna high. 

import pandas as pd
from prophet import Prophet
data = pd.read_csv("AAPL.csv")
X = data.loc[:, ['date','high']]
print(X.shape)
X.plot();

Saída

(1258, 2)

As ações da Apple estão aumentando com o tempo. Houve duas quedas, mas o movimento retomou um crescimento constante. 

Siga o tutorial de análise de séries temporais em Python do Hugo Bowne-Anderson para se aprofundar no tema. Você também pode fazer o curso rápido da DataCamp sobre análise de séries temporais em Python para colocar a mão na massa.  

Construindo o modelo de machine learning

Nesta parte, vamos preparar os dados para o modelo Prophet e treiná-lo com hiperparâmetros padrão. 

1. Renomear as colunas para ds e y
2. Converter a coluna ds para datetime (data)
3. Definir um model usando o Prophet()
4. Treinar o modelo usando model.fit()

X.columns = ['ds', 'y']
X['ds']= pd.to_datetime(X['ds'], format='%Y-%m-%d').dt.date

model = Prophet()
# fit the model
model.fit(X)

Avaliação do modelo

Para avaliar, precisamos adicionar datas futuras ao conjunto de dados. Podemos fazer isso usando make_future_dataframe. 

Vamos definir:

• periods para 365 dias
• freq como "D". Você também pode mudar para "Y", mas, nesse caso, deve alterar periods para 1.
• Definir include_history como false para omitir dados anteriores.

future = model.make_future_dataframe(periods=365,
                                    freq='D',
                                    include_history=False
                                    )
future.tail()

Saída

Como podemos ver, o dataset future termina no ano de 2021. 

        ds
360 2021-05-18
361 2021-05-19
362 2021-05-20
363 2021-05-21
364 2021-05-22

O próximo passo é usar esses dados para prever os valores de high das ações da Apple. Depois, vamos exibir 'ds', 'yhat', 'yhat_lower' e 'yhat_upper'. 

Os valores yhat_lower e yhat_upper definem a faixa aceitável de variação. Em outras palavras, o preço pode subir até 485,3 e cair para 365,4. Essas informações ajudam traders de curto prazo a avaliar o risco. 

forecast = model.predict(future)
forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail

Saída

    ds       yhat yhat_lower yhat_upper
360 2021-05-18 423.757736 365.415878 485.293438
361 2021-05-19 423.862811 365.527086 482.751097
362 2021-05-20 423.918642 365.233839 482.501335
363 2021-05-21 423.842872 364.454184 483.672508
364 2021-05-22 421.187822 360.181717 481.024524

Vamos visualizar os dados de previsão usando a função plot(). Ela precisa dos valores previstos para exibir o gráfico de pontos e linhas com a faixa aceitável em azul. 

model.plot(forecast)

A visualização abaixo mostra que as ações da Apple tendem a crescer sem quedas. 

Você pode melhorar a previsão ajustando hiperparâmetros relacionados a previsões saturadas, pontos de mudança de tendência (changepoints), sazonalidade, efeitos de feriados e regressores, sazonalidade multiplicativa, intervalos de incerteza e outliers. Também é possível ajustá-los automaticamente usando tuning de hiperparâmetros. Saiba mais sobre o Facebook Prophet lendo a documentação.  

Previsão de séries temporais é um campo amplo. Você pode aprender tudo seguindo nosso tutorial de time series forecasting do Moez Ali. O tutorial cobre análise de séries temporais, modelos estatísticos, frameworks em Python e AutoML. 

Você também pode fazer nosso curso de visualização de séries temporais em Python e aprender sobre gráficos de linha, detecção de sazonalidade, tendência e ruído, além de exibir múltiplas séries.  

Publicando a inferência do modelo 

Nesta seção, vamos publicar a inferência do modelo. Isso nos permite armazenar o modelo e a definição da função no servidor TabPy para oferecer respostas mais rápidas. 

Primeiro vamos conectar o Client usando URL e PORTA. Em seguida, vamos definir a função prophet_forecasting. 

1. Ela recebe um número de anos para previsão e usa esse valor para criar um dataframe de datas future. 
2. Faz previsões usando model.predict e o dataframe future. 
3. Renomeia "yhat" para "y" para podermos concatenar a previsão com os dados históricos. 
4. A última parte é delicada. No Tableau, não podemos adicionar valor ao campo data. Em vez disso, vamos deslocar os valores de Date por 365*n, onde n é o número de anos.

Por fim, vamos empacotar e publicar no servidor TabPy usando client.deploy(). Vamos definir o nome da função como "prophet". O argumento override nos ajuda a criar versões do modelo e da função. Isso é necessário na fase inicial, quando estamos depurando o código. 

from tabpy.tabpy_tools.client import Client

client = Client('http://localhost:9004/')

def prophet_forecasting(n):
 
    future = model.make_future_dataframe(periods=365*n,include_history=False)
    prediction = model.predict(future)
    prediction.rename(columns={"yhat":"y"}, inplace=True)
 
    return pd.concat([X,prediction[['ds','y']]])['y'].to_list()[365*n:]

client.deploy('prophet',
              prophet_forecasting,
              'forecast time series data using prophet',override=True)

Configurando o Tableau

Para controlar o número de anos no Tableau, precisamos criar um parâmetro Years. Ele será usado na função prophet. 

Você pode criar o parâmetro Years clicando com o botão direito na seção Data e selecionando a opção Create Parameter. Altere o Data type para Integer, defina o Current value como 1 e clique em Range para adicionar os valores Minimum 1 e Maximum 5.

Criando o parâmetro Years 

Depois disso, vamos criar um campo calculado Forecast_date. Vamos usar o campo de dados Date e deslocar os valores pelo número de Years. 

Campo calculado Forecast_date 

A função DATEADD adiciona Years ao campo de dados Date e depois trunca para o dia. 

DATETRUNC('day',DATEADD('year',[Years],[Date])))

Na próxima parte, vamos criar um campo calculado forecast e acessar o modelo publicado usando tabpy.query(). A função de consulta tem duas partes: a primeira é o nome da função Python e a segunda é a lista de placeholders para os argumentos. 

Campo calculado forecast 

No nosso caso, é apenas um argumento, então vamos adicionar _arg1. Vamos envolver a consulta em uma função do Tableau chamada SCRIPT_REAL e fornecer o parâmetro Years como entrada. Antes de clicar em OK, certifique-se de que os resultados sejam calculados ao longo de Forecast_date. Você pode alterar isso clicando no texto azul (Default Table Calculation).

SCRIPT_REAL("return tabpy.query('prophet',_arg1[0])['response']",
[Years]
)

Depois, vamos criar um campo calculado Actual usando o campo de dados High e o parâmetro Years. 

Campo calculado Actual 

LOOKUP nos ajuda a deslocar os valores de High por Years*365. Por exemplo, se o parâmetro Years estiver em 2, os valores serão deslocados em 730.

LOOKUP(SUM([High]),[Years]*365)

Real x previsão

Chegamos ao final. Para plotar o gráfico de linhas de Actual x forecast, siga estes passos simples:

1. Vá até a seção Parameters no canto inferior esquerdo, clique com o botão direito no parâmetro Years e selecione Show Parameters.
2. Arraste e solte Forecast_date na prateleira Columns. Altere para Day.
3. Arraste e solte Measure Names de Dimensions para Filters. Selecione apenas Actual e forecast. 
4. Arraste e solte Measure Names de Dimensions para Color.
5. Por fim, arraste e solte Measure Names de Measures na prateleira Rows.

Depois de seguir todos os passos, você verá Actual e forecast em cores diferentes. 

Gráfico de linhas de Actual x forecast

O gráfico acima está longe do ideal e requer tuning de hiperparâmetros, validação cruzada, imputação de valores e datas ausentes e melhorias na função de data. 

Conclusão

Neste tutorial, aprendemos a construir e publicar um modelo de machine learning no servidor TabPy e a acessá-lo usando script no Tableau. Também vimos o básico do tabpy_tools e como usá-lo para publicar funções ou modelos. 

Saiba mais sobre previsão financeira fazendo o curso da DataCamp. Você vai aprender a entender demonstrações de resultados, balanço patrimonial e índices projetados, formatação de dados brutos, gestão de datas e períodos financeiros, além de premissas e variações em projeções.

A previsão com séries temporais é o ponto de partida; podemos melhorar as previsões treinando os dados com outros algoritmos de machine learning, como:

• Autoregressive Integrated Moving Average (ARIMA)
• Seasonal Autoregressive Integrated Moving Average (SARIMA)
• Exponential Smoothing (ES)
• XGBoost
• LSTM (deep learning)
• Temporal Fusion Transformer (Google)

Se você está começando no Tableau e quer aprender tudo sobre visualização de dados e cálculos estatísticos, faça a trilha de habilidades Tableau fundamentals. 

Esta é a parte final da série. Na primeira parte deste tutorial de TabPy, aprendemos tudo sobre o TabPy e executamos um script em Python dentro do Tableau para criar diversos clusters de anúncios do Airbnb em Amsterdã.