Regras complexas, necessidade de converter indicadores de uma ferramenta de mercado para uma solução open source.

No meio do caminho, tomamos uma decisão mais ousada. Em vez de simplesmente trocar uma ferramenta por outra, abandonamos a abordagem tradicional e construímos algo sob medida: um portal de dashboards baseado em HTML, servido direto do Athena (nosso Data Lake), sem servidor de aplicação no meio.

O resultado? A migração levou 3 dias — não um ano.

Um pouco da solução que criamos:

→ Dashboards em HTML puro, com gráficos SVG renderizados no próprio navegador — sem depender de licenças ou infraestrutura pesada de BI.

→ O pulo do gato: usamos DuckDB direto no browser, executando SQL sobre arquivos Parquet. Na prática, o dashboard replica a interatividade completa (filtros, cruzamentos, drill-down) de uma ferramenta de BI tradicional — só que rodando na máquina de quem acessa.

→ Separação rígida entre dado e apresentação, orquestração via Airflow, deploy em ECS/Fargate e controle de acesso via SSO.

E aqui está o ponto que mais importa: a maior parte desse trabalho foi feita com apoio de IA. Foi ela que acelerou a geração de código, a replicação dos dashboards e a documentação.

Mas — e esse "mas" é fundamental — nada disso teria funcionado sem o expertise do time. Foi o conhecimento prático dos engenheiros que garantiu a qualidade, definiu a arquitetura, validou cada métrica e, de quebra, permitiu que aproveitássemos a migração para eliminar dashboards obsoletos ou incorretos que ninguém tinha coragem de mexer.

Hoje temos uma solução extremamente robusta que fornece indicadores corporativos para toda a empresa de forma estável, escalável e de fácil manutenção (também tocada de forma acelerada com IA)

Se eu puder deixar uma mensagem que pode gerar algum impacto positivo no seu trabalho é:

IA sem conhecimento prático é como dar um robô cirurgião para um macaco: até pode operar, mas nada de bom vai sair dali.

A ferramenta amplifica quem sabe o que está fazendo. Ela não substitui o saber

A jornada de um líder é, em sua essência, uma jornada de autoconhecimento. Quanto melhor nos entendemos – como agimos, como somos percebidos e o impacto que causamos – mais eficazes nos tornamos em guiar, inspirar e desenvolver nossas equipes.

No entanto, existe uma lacuna fundamental que todos nós possuímos: a diferença entre quem achamos que somos e como as outras pessoas realmente nos veem. É nesta lacuna que moram os maiores desafios e as mais ricas oportunidades de crescimento.

Para explorar esse espaço, existe um modelo psicológico brilhante e atemporal criado nos anos 50 por Joseph Luft e Harrington Ingham: a Janela de Johari.

A Janela de Johari

Imagine uma janela dividida em quatro painéis (áreas). Cada painel representa uma faceta da nossa personalidade e da nossa relação com os outros:

1. Área Aberta: Este é o painel da transparência. Contém as características que você conhece sobre si mesmo e que os outros também conhecem. Quanto maior esta área, mais eficaz é a comunicação, a confiança e a colaboração no time. Um líder com uma "Arena" grande tende a ser visto como autêntico e direto.

2.Área Cega: Aqui está o ouro do desenvolvimento! Este painel contém o que os outros veem em você, mas que você não percebe. Podem ser manias, reações, pontos fortes subestimados ou pontos fracos que impactam a equipe sem que você saiba. Descobrir seus pontos cegos é um presente, embora exija coragem para recebê-lo.

3. Área Oculta: Esta área guarda o que você sabe sobre si, mas escolhe não revelar aos outros por medo, insegurança ou desejo de manter certa imagem. Embora todos tenhamos direito à nossa privacidade, uma "Fachada" muito grande pode gerar desconfiança e criar barreiras na comunicação.

4. Área Desconhecida: O quadrante do potencial inexplorado. Representa as características e habilidades que nem você, nem os outros, conhecem ainda. Essa área pode ser descoberta através de novos desafios, experiências e, claro, do processo de dar e receber feedback.

O Poder da Dinâmica em Equipe

O objetivo ao usar a Janela de Johari não é expor ninguém, mas sim aumentar a área do "Eu Aberto" para todo o time, começando pelo líder.

Quando um líder se dispõe a explorar seus "Pontos Cegos", ele sinaliza para toda a equipe que a vulnerabilidade é uma força e que o desenvolvimento é um valor inegociável. Isso cria um ciclo virtuoso de confiança e segurança psicológica, onde a comunicação flui de forma mais honesta e construtiva.

Como colocar em prática de forma segura?

Tradicionalmente, a dinâmica da Janela de Johari é feita com post-its e conversas em grupo. No entanto, para que as pessoas se sintam seguras para apontar "pontos cegos" de uma liderança, o anonimato pode ser um catalisador poderoso.

Foi pensando em facilitar esse processo e garantir a segurança psicológica necessária que eu desenvolvi uma versão online e gratuita da dinâmica. A ferramenta permite que cada um faça sua autoavaliação e convide os colegas para contribuírem de forma anônima, organizando as respostas automaticamente nos quatro quadrantes.

Para explorar minha própria Janela de Johari eu criei o site https://teb-janelajohari.web.app/ para que eu e meu time pudéssemos realizar esta dinâmica mesmo estando em locais separados. Ela é gratuita e permite feedbacks 100% anônimos de forma clara e que lhe ajudarão no seu desenvolvimento.

Em tempos de IA, ao final é oferecido um prompt que pode ser utilizado no Chat GPT, Google Gemini ou qualquer outra ferramenta que você desejar :)

O verdadeiro crescimento na liderança não vem de ter todas as respostas, mas de ter a coragem de fazer as perguntas certas sobre nós mesmos.

Você já conhecia a Janela de Johari? Qual dos quatro quadrantes você acredita que tem mais potencial de transformação na sua carreira? Vamos conversar nos comentários!

#Autoconhecimento #Liderança #DesenvolvimentoPessoal #JanelaDeJohari #InteligenciaEmocional #ComunicaçãoEficaz #Psicologia #GestãoDePessoas #CulturaOrganizacional

I believe that multilevel models or generalized linear models are one of the best tools for predicting continuous values, given their adaptability and explanatory capacity. However, like other machine learning methods, they also pose a challenge when you need to define which variables should be used to achieve the best results.

A common strategy for refining multilevel models is the step-up approach, a method proposed by Raudenbush and Bryk in a 2002 article. This technique involves an iterative process where variables are gradually added to the model based on statistical criteria, such as the p-value and a regression coefficient like the log-likelihood, Bayesian Information Criterion (BIC), or Akaike Information Criterion (AIC).

In the step-up strategy, an initial null model is created without predictor variables to assess the statistical significance of random intercept effects. Then, the model is enriched with other variables, and this step is repeated until the final model or complete model is created. I covered this topic in an article I wrote for the conclusion of an MBA last year, and the PDF can be accessed through this link (in portuguese).

Considering a way to ensure the best possible result for a model, I followed a slightly different approach, creating a refinement method aimed at achieving the best model regardless of the step-up strategy.

This approach aims to test all possible combinations of level 1 and level 2 variables to find the best possible indicators, which are:

• Log-likelihood: a widely used method for model comparison in the academic field.
• BIC (Bayesian Information Criterion): a method that builds upon the Log-likelihood but applies a penalty based on the number of parameters in the model. Therefore, more complex models need to show a better improvement compared to models with fewer parameters.
• RMSE (Root Mean Squared Error): a measure that compares predicted values with actual values and prevents positive and negative deviations from canceling each other out. Taking advantage of the deterministic nature of regression models, where results are predictable, this indicator can be calculated while evaluating the model using the same training dataset for testing.

Below, I present a practical example of this strategy.

This method was created with the help of Python, using the “MixedLM” method from the “statsmodels” package, and it follows some naming conventions used by the package and others that complement its execution:

• y_variable: the name of the response variable, which will be generated by the model.
• formula_variables: a list of higher-level variables.
• groups: the variable used as a grouping factor.
• re_formula_variables: a list of lower-level variables.
• data: a DataFrame containing the data for model creation.
• detailed_verbose (default False): indicates whether all tested combinations will be displayed during execution (True) or only the final result (False).
• show_best_model_summary (default True): indicates whether the summary of the model will be displayed at the end of execution according to the “summary()” method.
• class_criterion (default ‘llk’): indicates the model’s classification criterion, which can be ‘llk’ for Log-likelihood, ‘bic’ for Bayesian Information Criterion, or ‘RMSE’ for Root Mean Squared Error.
• icc_test (default False): indicates whether the intraclass correlation coefficient value should be displayed, which is used to assess the percentage of data impacted by grouping at different levels.
• hlm_model_check (default False): indicates whether the p-value of the model should be displayed. This information helps identify whether the null model is statistically significant at a 95% confidence level. This way, it is possible to check the significance of the random term and determine if traditional models such as Ordinary Least Squares (OLS) are suitable for this scenario (Tabachnick and Fidell, 2013).

Considering the fictitious dataset:

Given the dataset provided:

• loja: Store identifier
• cidade: City identifier
• receita: Accumulated revenue in 12 months
• nps: Net Promoter Score in 12 months
• tempo_medio_contrato: Average contract duration of the sales team
• perc_fidelidade: Percentage of loyalty club customers who made a purchase in this store in 12 months
• inflação: City’s inflation percentage in 12 months
• desemprego: City’s unemployment rate in 12 months
• pib: City’s Gross Domestic Product (GDP) in 12 months

It is possible to observe that the variables can be separated into 2 levels:

• Level 1 — Store: receita, nps, tempo_medio_contrato, and perc_fidelidade
• Level 2 — City: inflação, desemprego, and pib

With this in mind, the execution of all possible combinations for evaluating random intercepts and slopes in a multilevel model would be as follows:

hlm2_refined = hlm2_model_test(
    y_variable = 'receita', 
    formula_variables = ['desemprego', 'inflacao', 'pib'],
    groups = 'cidade', 
    re_formula_variables = ['nps', 'tempo_medio_contrato', 'perc_fidelidade'],
    data = df_sells,
    class_criterion = 'llk')

Note that level 1 variables (store) are listed in the re_formula_variables property, while level 2 variables (city) are listed in the re_formula property. In this case, we will have 49 combinations [(3 + 3 + 1) * (3 + 3 + 1)], and here are some examples:

• Formula = receita ~ desemprego and re_formula = nps
• Formula = receita ~ desemprego and re_formula = nps + tempo_medio_contrato
• Formula = receita ~ desemprego + inflacao and re_formula = nps

Each combination will generate and evaluate a model, and in the end, they will be ranked according to the chosen criterion, in this case, log-likelihood. After ranking, the results of the process will be displayed, divided into two parts:

Best model: A summary of the model and classification criterion result.

Summary: with the summary of the selected model using the MixedLM method.

To create a model that considers the influence of city-level variables on the stores, it is necessary to modify the method call, now considering these effects, as shown in the example below:

hlm2_final = hlm2_model_test(
    y_variable = 'receita', 
    formula_variables = ['desemprego', 'inflacao' ,
                         'nps', 'tempo_medio_contrato',
                         'nps:desemprego', 'nps:inflacao',
                         'tempo_medio_contrato:desemprego', 'tempo_medio_contrato:inflacao'],
    groups = 'cidade', 
    re_formula_variables = ['nps', 'tempo_medio_contrato'],
    data = df_sells,
    class_criterion = 'llk')

In this case, there will be 765 or [(8 + 28 + 56 + 70 + 56 + 28 + 8 + 1) * (2 + 1)] model combinations to be evaluated, and this process will take a little longer, depending on the computer where it is being executed. In the end, we will have the result, separated in the same way as in the previous example:

Best Model

Summary

Please note that this time there are variables that did not show statistical significance at a 95% confidence level. However, the log-likelihood improved compared to the previous model, and the combinations without these variables did not show an improvement in predictive capability, so they were discarded.

Since the return of this method is a DataFrame with all the combinations tested, the indicators, and a copy of the model generated by the MixedLM method, it is possible to evaluate the tests performed and compare them. To obtain the best model, simply execute the command:

hlm2_final_model = hlm2_final.iloc[0]['model']

In this example, the variable hlm2_final_model will store the model generated by the MixedLM method. To visualize the top five evaluated models, we can use the head command, as shown in the example below:

hlm2_final.head(5)

The codes used here and more information about the dataset used can be found on my GitHub.

If you have found any errors or have any suggestions for improvement, please send me a message at marcosmhs@live.com, and I will be glad to further enhance this text and give you credit.

Imagine que você criou uma carteira de investimentos, com ações de empresas que você conhece e acredita que pode gerar bons resultados e estão alinhadas com seus critérios de ESG e governança. Vamos supor que você selecionou 6 empresas e possui R$ 60.000 para iniciar sua carteira. Se você preparou 6 cheques de R$ 10.000 para enviar para o escritório de cada uma eu tenho 2 más notícias… A primeira é que não é assim que se compra ações e a segunda é que você pode estar fazendo um mal negócio.

Isso porque empresas diferentes possuem rendimentos diferentes e se o objetivo aqui é garantir um bom rendimento é necessário pensar em como maximizar seus lucros.

Foi isso o que pensou Willian Sharpe em 1966 quando criou um índice para ajudar a encontrar o percentual de investimento em cada item de sua carteira afim de maximizar o retorno com o menor risco possível utilizando apenas os dados históricos das ações. Este índice recebeu o nome de Sharpe Ratio!

Bora lá entender como calcular este negócio, usando o Python!

Como sempre vamos preparar nosso ambiente com as bibliotecas necessárias

import yfinance as yf
import datetime
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

from scipy.optimize import minimize
from pandas_datareader import data as web

# definição do período de seleção dos dados históricos das ações analisadas
start date = datetime.datetime(2022,1,1)
end_date = datetime.datetime(2022,11,30)

Em seguida vamos selecionar as 6 ações de nossa carteira fictícia, neste caso:

• Gerdau (GGBR4.SA) — Produtora de aço
• Copel (CPLE6.SA) — Companhia de fornecimento de energia Paranaense
• Assaí (ASAI3.SA) — Atacadista
• Itaú (ITUB4.SA) — Banco
• Natura (NTCO3.SA) — Produtos de beleza
• Vale (VALE3.SA) — Mineradora

# houve uma alteração no retorno do yahoo finance e esta linha é 
# necessária até que o Pandas DataReader seja corrigido.
yf.pdr_override()
#Gerdau
goau = web.get_data_yahoo(['GOAU4.SA'], start = start_date, end=end_date)
#Copel
cple = web.get_data_yahoo(['CPLE6.SA'], start = start_date, end = end_date)
# Assaí
asai = web.get_data_yahoo(['ASAI3.SA'], start = start_date, end = end_date)
#Itaú
itub = web.get_data_yahoo(['ITUB4.SA'], start = start_date, end = end_date)
#Natura
ntco = web.get_data_yahoo(['NTCO3.SA'], start = start_date, end = end_date)
#Vale
vale = web.get_data_yahoo(['VALE3.SA'], start = start_date, end = end_date)
# lista com os nomes das ações
stocks_names = ['Gerdau', 'Copel', 'Assaí', 'Itaú', 'Natura', 'Vale']

Vamos utilizar o código abaixo para ter uma noção do desempenho de cada uma:

fig = plt.figure(figsize = (20,8))
gs = fig.add_gridspec(2, 3, wspace = 0)
(ax1, ax2, ax3), (ax4, ax5, ax6) = gs.subplots()

ax1.plot(goau['Close'])
ax1.set_title(stocks_names[0])
ax2.plot(cple['Close'], )
ax2.set_title(stocks_names[1])
ax3.plot(asai['Close'], 'tab:green')
ax3.set_title(stocks_names[2])
ax4.plot(itub['Close'], 'tab:red')
ax4.set_title(stocks_names[3])
ax5.plot(ntco['Close'], 'tab:blue')
ax5.set_title(stocks_names[4])
ax6.plot(vale['Close'], 'tab:gray')
ax6.set_title(stocks_names[5])

Podemos ver que a Gerdau, Copel e Assaí apresentam padrões de crescimento interessantes, enquanto Natura, Itaú e Vale trazem queda ou crescimento tímido

Como os dados estão separados em 6 dataframes diferentes precisamos uni-los em um só local e nesta união utilizaremos apenas a coluna Close, que armazena o valor do fechamento da ação em um dia

# com o concat será feita a união dos dataframes. A opção axis indica que queremos os dados sejam colocados em colunas diferentes ao invés de concatenar as linhas
stocks = pd.concat([
    goau['Close'], 
    cple['Close'], 
    asai['Close'],
    itub['Close'],
    ntco['Close'],
    vale['Close']
    ],axis= 1)
# agora renomeamos as colunas para que tenham o nome de suas respectivas ações
stocks.columns = stocks_names

stocks. Head(5)

Agora vamos preparar os dados para a análise, começando pela criação de uma matriz com o retorno de cada ação por data, seguindo a fórmula:

Onde:

• R é o retorno
• P é o preço
• P-1 é o preço na data anterior

Todos os elementos são subscritos (t), ou seja, todos são em função do tempo.

# neste caso o shift faz o LAG do valor, ou seja, pega o valor correspondente ao dia anterior
returns = stocks / stocks.shift(1)
# vemos que os primeiros valores são inválidos pois não há uma data anterior para o cálculo
returns. Head(5)

Em seguida faremos a padronização dos valores:

Mas não se preocupe porque no Python isso é muito fácil:

log_returns = np.log(returns)
log_returns.head(5)

Podemos ver que os valores, que antes oscilavam entre R$ 6 (Copel) e R$ 71(Vale), agora oscilam entre -1 e 1

Calculando o Sharpe Ratio

Como dito anteriormente, este índice considera o retorno de acordo com o risco envolvido, utilizando dados históricos. Abrindo um pouco a caixa do método, temos a fórmula:

Onde

• SR é o Sharpe Ratio, o valor que desejamos obter
• (w) é o peso de cada ação. Neste caso o valor normalizado de todos os valores de nossa lista, ou seja, ao somar todos os valores teremos 1 como resultado. Esse valor irá ajudar a definir o percentual de nosso investimento em cada ação. Neste exemplo, w1 é Gerdau, w2 é Copel e assim por diante
• R(f) é o retorno caso não exista risco, e como veremos mais adiante é um valor desprezado, não precisaremos dele.
• Sigma é desvio padrão ou volatilidade

w é a soma dos pesos dentro de um determinado dia

R(w) é retorno do investimento: matriz transposta dos pesos multiplicado pelo valor do dia anterior (log)

sigma(w) — risco do investimento é a raiz da matriz transposta de pesos multiplicado pela soma dos pesos

Ao final teremos a fórmula que será utilizada:

Agora sim, vamos ao cálculo do retorno vs volatilidade, neste caso avaliaremos 10.000 portfólios diferentes, gerando peso aleatórios para cada uma das ações

number_of_portfolios = 10000
number_of_stocks = len(stocks.columns)

# vamos criar os vetores que serão utilizados e iniciá-los com zero
weights = np.zeros((number_of_portfolios, number_of_stocks))
expected_return = np.zeros(number_of_portfolios)
expected_volatility = np.zeros(number_of_portfolios)
sharpe_ratio = np.zeros(number_of_portfolios)

# Como utilizaremos a média dos retornos padronizados (log_returns), 
# vamos calculá-la agora para evitar processamento excessivo durante o loop
mean_log_returns = log_returns.mean()

# utilizaremos a matriz de covariância (grau de interdependência) 
# entre as ações de nossa base
sigma = log_returns.cov()

# vamos correr todo o portfólio, quanto maior o número de 
# iterações maior a quantidade combinações a serem feitas
for i in range(number_of_portfolios):
    
    # (w)
    # criar vetor com pesos aleatórios, usado em cada uma das iterações
    w = np.array(np.random.random(number_of_stocks))
    # encontra o percentual de cada peso gerado anteriormente
    w = w / np.sum(w)
    
    # salva o valor dentro da matriz
    weights[i,:] = w
    
    # R(w)
    # calcular o log return multiplicando o valor com LAG pelo peso. 
    # Esta matriz terá apenas uma coluna, com o retorno esperado para 
    # aquele dia de todas as ações da carteira
    expected_return[i] = np.sum(mean_log_returns * w)

    # sigma(w)
    expected_volatility[i] = np.sqrt(
        np.dot(
            w.T,
            np.dot(sigma, w)
        )
    )

    # Sharpe ratio, o retorno dividido pela volatilidade
    sharpe_ratio[i] = expected_return[i] / expected_volatility[i]

Uma vez calculado o Sharpe ratio para todos os portfólios vamos verificar o melhor índice, aquele com maior retorno.

# retorna a posição que garante o maior retorno nas ações 
# de acordo com o sharpe ratio
max_index = sharpe_ratio.argmax()

# agora podemos ver qual o percentual de nosso orçamento que 
# podemos alocar em cada uma das ações para maximizar nosso retorno.
weights[max_index, :]

Para melhorar a visualização dos dados podemos criar um gráfico de barras, com o código abaixo

plt.figure(figsize=(16,5))
hbars = plt.bar(
    x = stocks_names, 
    height=weights[max_index, :] * 100
)
plt.bar_label(hbars, fmt='%.2f')
plt.ylabel('% de Investimento')
plt.title('Distribuição do investimento no portfólio selecionado')
plt.show()

Segundo o Sharpe Ratio devemos investir 50% de nosso orçamento em ações do Assaí (ASAI) e menos de 1% nas ações da Vale (VALE).

O interessante deste modelo é que ele pode ser aplica à praticamente qualquer carteira, desde que se tenha dados históricos em um mesmo período de todas as ações dela

Vamos visualizar os, dentro de todo o portifólio criado onde está o nosso ponto que maximiza o Sharpe Ratio

plt.figure(figsize = (16,8))
# plota a volatilidade e o retorno classificado de acordo 
# com o maior valor do Sharpe Ratio
plt.scatter(
    expected_volatility, 
    expected_return, 
    c=sharpe_ratio
)
plt.xlabel('Volatilidade esperada')
plt.ylabel('Retorno Esperado')
plt.title('Comparação entre portfólio')
plt.colorbar(label = 'SR', extend = 'max')
# plota em vermelho o max_index, ou seja, o ponto de maior 
# retorno e menor risco
plt.scatter(
    expected_volatility[max_index], 
    expected_return[max_index], 
    c='red', 
    s=70,   
)
plt.show()

Podemos observar no gráfico acima que os maiores retornos (em amarelo) estão no limite superior de nossa amostra, e cabe ao investidor avaliar o risco (eixo X) que deseja correr para alcançar aquele retorno.

O ponto vermelho indica o maior retorno que podemos ter com o menor risco possível.

Bacana, não é?

Como o objetivo deste texto não é ajudar na previsão de receita e sim ajudar a definir o valor de investimento baseado em dados históricos, deixo aqui o link de um texto (em inglês) que escrevi sobre o uso de uma rede neural LSTM para a predição do valor de ações, aqui mesmo no Medium.

Caso tenha encontrado alguma “câimbra mental” ou mesmo um erro de código por favor me avise através do e-mail marcosmhs@live.com e eu ficarei feliz em corrigir o texto e creditá-lo.

Como sempre o código completo pode ser encontrado em meu GitHub

Investir seu rico dinheirinho é um assunto delicado, muitos tem medo de perder outros tem medo de não ganhar. Como eu me encaixo nestes dois cenários e por ter a terrível mania de investir na alta e vender na baixa, perdendo sempre tento recorrer aos números como forma de evitar perder o pouco que sobrou.

Brincadeiras à parte tenho consegui algum sucesso observando alguns investidores e olhando para indicadores que ajudam a determinar se um papel vai ou não dar retorno.

Encontrei recentemente um script que listava os fundos imobiliários com pagamento de dividendos e aproveitei para expandir seu uso para me ajudar a encontrar aqueles que fazem mais sentido investir.

Vamos ao código!

import pandas as pd
import requests
import webbrowser
from ipywidgets import interact, interact_manual

Os dados virão do site www.fundsexplorer.com.br, para isso usei o pacote request para acessar o ranking de fundos disponíveis

pd.options.display.float_format = '{:.2f}'.format
page_data = requests.get("https://www.fundsexplorer.com.br/ranking").text

Uma vez obtido os dados do site foi necessário transformá-los em um dataframe e fazer algumas conversões.

df_fiis = pd.read_html(page_data)[0]

# remove os caracteres que irão impedir conversão de dados
df_fiis = df_fiis.replace(["R\$", "%", "\."], "", regex = True)

# substitui , por . (para permitir a transformação do string em float)
df_fiis = df_fiis.replace(",", ".", regex = True)

# valor do P/VPA muda durante a importacão, isso é necessário para retorná-lo ao valor original
df_fiis["P/VPA"] = df_fiis["P/VPA"] / 100
df_fiis["VPA"] = pd.to_numeric(df_fiis["VPA"], downcast="float") / 100

Visualizando os dados vemos que temos 25 colunas com os dados necessários para nossa análise. No código fonte eu detalho um pouco mais algumas delas.

df_fiis.head()

Neste exemplo eu vou analisar todas os fundos disponíveis até e no futuro manterei apenas aqueles que tenho maior interesse em investir. Para isso eu criei a lista fii_list com o código de todos os fundos.

fii_list = df_fiis['Código do fundo'].unique().tolist()

Na sequência eu calculei a nota de todos os fundos multiplicando o:

o Indicador calculado pela divisão do preço da cota sobre o valor do patrimonial do fundo pela Média do Dividend Yield no último ano

Desta forma é possível identificar os fundos que podem gerar maior retorno neste período

filtered_fiis = df_fiis[df_fiis["Código do fundo"].isin(fii_list)]
analized_fiis = filtered_fiis[["Código do fundo", "Setor", "Preço Atual", "Dividend Yield", "DY (3M) Média", "DY (6M) Média", "DY (12M) Média", "VPA", "P/VPA"]]

analized_fiis['Nota'] = (
                                (1 / analized_fiis['P/VPA']) 
                                * pd.to_numeric(df_fiis["DY (12M) Acumulado"], downcast="float")
                           )

analized_fiis.sort_values(by=["Nota"], inplace=True, ascending=[False])

Ao final teremos o dataframe analized_fiis com o resultado de nossa análise, classificados da maior nota (melhor) para a menor (pior)

analized_fiis.nlargest(10, 'Nota')

Para ajudar em minha análise também criei uma função que retorna um determinado fundo e abre o site fundsexplorer com os detalhes

def list_fii_data(fundo):
    webbrowser.open_new('https://www.fundsexplorer.com.br/funds/' + fundo)
    return analized_fiis.set_index('Código do fundo').loc[[fundo]]

interact(
    list_fii_data, 
    fundo= analized_fiis.sort_values(by=["Código do fundo"])['Código do fundo'].unique(). tolist()
    
)

O código fonte pode ser acessado em meu github!

Caso encontre algum erro ou câimbra mental me avise no marcosmhs@live.com e ficarei feliz em fazer os ajustes garantindo o devido crédito à sua contribuição. :)

Hive is one of the most interesting resources to store and access local data on Flutter applications. And for me the best feature is the ability to store and recover Dart classes. To do that Hive uses Type Adapters, a method that transform your classes in data that can be stored.

On next I will resume in a few steps how to use the Hive with Type Adaptors but I´m recommend you see all the steps in detail and execute these codes in your computer you by downloading the complete exemple on my GitHub

1. Install packages

The necessary packages to use Hive are:

• hive
• hive_flutter
• hive_generator
• build_runner

2. Initiate flutter

Once the packages installed you need to initiate Hive on your app, the main() method on main.dart is a good place for that.

3. Create adapter file

As we are working to store entire classes, on the class file, in this case person.dart is necessary indicate the file that will be created by Hive generator. I will talk more about the adapter file on step 5 :)

Important: you will need to do that in all classes files that you want to store!

4. Indicate IDs to classes and atributes

With the indication of adaptor file in the class you need to indicate to Hive generator witch classes and columns will be storage. Is importante to have in mind that each class should be a unique typeId and inside the classes the fields also should be a unique ID

5. Run flutter command

After all classes be prepared run the command below on your terminal

The command flutter packages pub run build_runner build will read all classes in your code and create adapters to translate your classes to binary data and vice versa when you read de stored data. These files will use the name that you indicate on step 3

6. Register adapter

After the execution of the previous step each class with and @HiveType will have and adapter and needed to be register, I’m also recommend the use of main method

7. Opening the box

Now that your application is ready it´s time to understand an importante feature of Hive: the data are stored in boxes and to save and acesses your data you need to open those boxes. To do that I´m use the method bellow to verify if a box is already open and return it or if it needs to be opened.

8. CRUD

After the opening the data box, you can start the CRUD operations, like the images below

You can find the Hive documentation and more detains on Hive Docs website

This method creates a LSTM neural net capable of predict a stock time series using Keras.

I wrote about LSTM and time series on this article in RPubs site (in Portuguese).

The code of the method could be downloaded on my Github.

Execution steps

The method structure could be resumed in the image bellow

Code Examples

Method creation:

#using GitHub Strocture

source('lstm_stock_function.R')

On a first example I with use META (Facebook, WhatsApp, Instagram, etc) stocks and for now I don´t need a ARIMA comparison

return_meta <- 
    lstm_stock(
      stock_name = 'META', 
      start_date = '2019-01-01', 
      lstm_executions = 10, 
      lstm_verbose = F)

## [1] "-----------------------------------"
## [1] "Execution completed..."
## $parameters
##   stock_name start_date   end_date arima_compare
## 1       META 2019-01-01 2022-09-12         FALSE
## 
## [1] "MSE"
## 1  2.53

As we can see the data shows us a growing trend and the normalization was needed to create the neural net.

The prediction plot show that the model was capable to predict results remarkably close to the real prices

On a second example the lstm_stock will use data from Petrobrás (brazilian oil company). The data will be extract from Bovespa (brazilian stock market) from 2015 until today. The method will execute a LSTM neural net with 10 iterations and in the end will also execute and ARIMA model to compare the results

return_petr4 <- 
    lstm_stock(
      origin = '^BVSP', 
      stock_name = 'PETR4.SA', 
      start_date = '2015-01-01', 
      lstm_executions = 10, 
      arima_compare = T,
      lstm_verbose = F)

## [1] "Execution completed..."
## $parameters
##   stock_name start_date   end_date arima_compare
## 1   PETR4.SA 2015-01-01 2022-09-12          TRUE
## 
## [1] "MSE"
##   variable        value
## 1     lstm 4.203284e-01
## 2    arima 7.725121e-05

Again, the data shows us a growing trend and the normalization was needed to create the neural net.

The LSTM prediction chart (on left) show us some error on the predicted value, while the ARIMA model present a better result. That perception could be confirmed by the MSE results:

## [1] "MSE"
##   variable        value
## 1     lstm 4.203284e-01
## 2    arima 7.725121e-05

To end this text, if you find some bug or “brain cramp” please e-mail me on marcosmhs@live.com and I will be glad on correct the code and register your name on the credits.

A maleabilidade e adaptabilidade das florestas aleatórias são uma das muitas vantagens deste tipo de modelo. Da previsão do tempo à análise de risco de crédito, esse tipo de método tem muitas aplicações. E risco de crédito é o tema desse artigo.

Vagando pelo banco de dados infinito do Kaggle encontrei um banco de dados de com registros de 887 mil registros de empréstimos com dados dos mutuários e a situação do empréstimo.

Com o conjunto de dados em meu computador, iniciei a análise inicial para entender as dimensões e as variáveis.

Mas antes, preciso importar as bibliotecas necessárias e para isso gosto de usar esse método que as importa e instala automaticamente:

pkgs = 
 c(“plotly”,”tidyverse”,”reshape2",”knitr”,”kableExtra”,”rgl”,”car”,
 “jtools”, “data.table”, “GGally”, “cowplot”, “janitor”,
 “funModeling”, “modeldata”, “Metrics”)

if(sum(as.numeric(!pkgs %in% installed.packages())) != 0){
 install = pkgs[!pkgs %in% installed.packages()]
 for(i in 1:length(install)) {
 install.packages(install, dependencies = T)
 break()}
 sapply(pkgs, require, character = T) 
} else {
 sapply(pkgs, require, character = T) 
}

Com os pacotes instalados podemos fazer a importação dos dados utilizando o comando fread:

data = fread("loans.csv")

Obs: eu sei que em R o correto é fazer uma atribuição utilizando <-, porém meu cérebro não aceita bem isso e sigo usando o =. Por favor não me julguem :)

Temos duas colunas de identificação nesta base, id e member_id ambas desnecessárias para nossa análise. Manterei a coluna id como identificador das linhas e removerei member_id.

data_cleaned =
   data %>%
   # column id transformed in row name
   column_to_rownames("id") %>%
   # removing column member_id
   select(everything(), -member_id)

Após a remoção destas duas colunas o dataset permanece ainda com 72 colunas. Será necessário fazer a análise de cada uma delas para determinar aquelas que são relevantes para o modelo. Observe que ao invés de trabalhar no dataset original eu criei um novo, com isso mantenho os dados originais intactos e evito novas importações. A partir deste ponto todo o trabalho será feito com o dataset data_cleaned.

Análise de variáveis categóricas

As random forests trabalham bem com variáveis categóricas, porém é importante verificar a quantidade de “categorias” presentes em cada variável para que reduzamos a amplitude das informações sem perdermos sua objetividade. Muitas categorias podem tornar a análise inviável fragmentando os resultados gerados. Lembre-se, modelos preditivos tentam prever o futuro e dar muitas opções aumenta a taxa de erro podendo inviabilizar o resultado.

Iniciaremos listando as variáveis categóricas, que nesta base de dados são todas do tipo texto.

data_cleaned %>% 
   # selecting character columns becouse I  
   select_if(is.character) %>% 
   names() %>%
   reshape2::melt()

                       value
1                       term
2                      grade
3                  sub_grade
4                  emp_title
5                 emp_length
6             home_ownership
7        verification_status
8                    issue_d
9                loan_status
10                pymnt_plan
11                       url
12                      desc
13                   purpose
14                     title
15                  zip_code
16                addr_state
17          earliest_cr_line
18       initial_list_status
19              last_pymnt_d
20              next_pymnt_d
21        last_credit_pull_d
22          application_type
23 verification_status_joint

Vamos primeiro falar sobre nossa variável alvo a loan_status, que indica qual a situação daquele empréstimo.

data_cleaned %>% 
   tabyl(loan_status) %>% 
   adorn_pct_formatting() %>% 
   arrange(desc(n))

                                          loan_status      n percent
                                              Current 601779   68.0%
                                           Fully Paid 207723   23.5%
                                          Charged Off  45248    5.1%
                                   Late (31-120 days)  11591    1.3%
                                               Issued   8460    1.0%
                                      In Grace Period   6253    0.7%
                                    Late (16-30 days)   2357    0.3%
                                              Default   1219    0.1%
  Does not meet the credit policy. Status:Charged Off    761    0.1%

Como pode-se observar, um empréstimo pode ter vários status, dependendo do momento:

· Current: indica que o empréstimo está ativo e com pagamentos em dia

· Fully Paid: empréstimos totalmente pagos e finalizados

· Charged Off: indica que a dívida do empréstimo é incobrável.

· Late (31-120 days): empréstimo possui pagamentos com atraso entre 31 e 120 dias

· Issued: empréstimos recentemente liberados, ainda sem pagamentos emitidos ou recebidos

· In Grace Period: empréstimo possui pagamento em período de carência, ou seja, vencido entre 1 e 15 dias

· Late (16-30 days): empréstimo possui pagamentos com atraso entre 16 e 30 dias

· Default: quando o titular do empréstimo não é capaz de realizar pagamentos por um longo período (superior a 120 dias)

· Does not meet the credit policy. Status:Charged Off: solicitação do empréstimo é cancelada quando o titular possui dívidas consideradas incobráveis.

Avaliando os possíveis valores podemos separá-los em três grupos:

Bons pagadores

· Fully Paid

Maus pagadores

· In Grace Period, Late (16-30 days) e Late (31-120 days) e Default indicam potenciais atrasos em pagamento

· Charged Off indica uma dívida que não será recebida sem a necessidade de apoio jurídico

Indefinido (situação não indica se os pagamentos podem ou não atrasar:

· Current empréstimos com pagamento em dia não necessariamente indicam que serão totalmente pagos dado que pode haver atraso em parcelas futuras

· Issued: e Does not meet the credit policy. Status:Charged Off representam empréstimos que não iniciaram ou nunca serão iniciados

Como eu comentei anteriormente é importante tentarmos reduzir a quantidade de categorias sempre que possível, neste caso, podemos transformar a coluna loan_statusem uma nova coluna com 2 valores que indiquem a informação que desejamos: bons e maus pagadores. Também podemos reduzir a quantidade de dados, removendo da base de dados empréstimos que não possuem informações relevantes, neste caso aqueles com a situação considerada indefinida.

Vamos começar pela exclusão dos lançamentos que não serão utilizados no modelo.

data_cleaned = 
   data_cleaned %>%
   filter(!loan_status %in% c(
      "Current", 
      "Does not meet the credit policy. Status:Charged Off", 
      "Issued"
   )
)

Agora vamos simplificar a nossa variável resposta:

data_cleaned =
   data_cleaned %>%
   # creates a new column with the value from good and bad borrow
   mutate(
      target = ifelse(
         loan_status == 'Fully Paid', 
         'Good borrow',
         'Bad borrow')) %>%
   # select all columns minus the loan status
   select(everything(), -loan_status)

Obs: mantive os valores em inglês para seguir o padrão da base. Utilizei a função ifelse para simplificar o código, já que somente os empréstimos totalmente pagos são considerados bons.

Vamos executar novamente a verificação dos valores agora na variável target para verificarmos como ficaram distribuídos os novos valores.

data_cleaned %>% 
   tabyl(target) %>% 
   adorn_pct_formatting() %>% 
   arrange(desc(n))

       target      n percent
  Good borrow 207723   75.7%
   Bad borrow  66668   24.3%

Seguindo a análise com as demais variáveis categóricas, eu as separei em 3 grupos:

Grupo 1 — Variáveis que serão deixadas como estão

Estas variáveis não precisam de tratamento. Apenas uma observação sobre a variável addr_state, embora ela possua muitas categorias (estados americanos) entendo que ela é relevante pois pode ajudar a indicar em quais estados existe maior chance de calote na dívida.

data_cleaned %>% 
   tabyl(emp_length) %>% 
   adorn_pct_formatting() %>%
   arrange(desc(n))

##  emp_length     n percent
##   10+ years 83448   30.4%
##     2 years 25479    9.3%
##    < 1 year 22738    8.3%
...

data_cleaned %>% 
   tabyl(addr_state) %>% 
   adorn_pct_formatting() %>% 
   arrange(desc(n))

##  addr_state     n percent
##          CA 46195   16.8%
##          NY 23446    8.5%
##          TX 21012    7.7%
...

data_cleaned %>% 
   tabyl(term) %>% 
   adorn_pct_formatting() %>% 
   arrange(desc(n))

##       term      n percent
##  36 months 209857   76.5%
##  60 months  64534   23.5%

data_cleaned %>% 
   tabyl(home_ownership) %>% 
   adorn_pct_formatting() %>% 
   arrange(desc(n))

##  home_ownership      n percent
##        MORTGAGE 134317   49.0%
##            RENT 115685   42.2%
##             OWN  24204    8.8%
...

data_cleaned %>% 
   tabyl(purpose) %>% 
   adorn_pct_formatting() %>% 
   arrange(desc(n))

##             purpose      n percent
##  debt_consolidation 162080   59.1%
##         credit_card  53936   19.7%
##    home_improvement  16142    5.9%
...

Grupo 2 — Variáveis que serão removidas

Estas variáveis trazem informações unitárias, como observações de cada empréstismo, URL com informações da solicitação, CEP do cliente e datas de aprovação.

# the zip code isn´t an option becose the state code will be used as a location info 
# commented to avoid unnecessary processing
#data_cleaned %>% 
#   tabyl(zip_code) %>% adorn_pct_formatting() %>% arrange(desc(n))

# month when loand was funded 
# commented to avoid unnecessary processing
#data %>% 
#   tabyl(issue_d) %>% adorn_pct_formatting() %>% arrange(desc(n))

# indicate of the bank verified the borrowers' 
data_cleaned %>% 
   tabyl(verification_status) %>% 
   adorn_pct_formatting() %>% 
   arrange(desc(n))

##  verification_status      n percent
##             Verified 100925   36.8%
##         Not Verified  90739   33.1%
##      Source Verified  82727   30.1%

# month that credit line was opened 
# commented to avoid unnecessary processing
#data_cleaned %>% 
#   tabyl(earliest_cr_line) %>% adorn_pct_formatting() %>% arrange(desc(n))

# commented to avoid unnecessary processing 
#data_cleaned %>% 
#   tabyl(emp_title) %>% adorn_pct_formatting() %>% arrange(desc(n))

# that variable have the same value for almost the role dataset.
data_cleaned %>% 
   tabyl(pymnt_plan) %>% 
   adorn_pct_formatting() %>% 
   arrange(desc(n))

##  pymnt_plan      n percent
##           n 274384  100.0%
##           y      7    0.0%

# commented to avoid unnecessary processing
#data_cleaned %>% 
#   tabyl(url) %>% adorn_pct_formatting() %>% arrange(desc(n))

# commented to avoid unnecessary processing
#data_cleaned %>% 
#   tabyl(desc) %>% adorn_pct_formatting() %>% arrange(desc(n))

# commented to avoid unnecessary processing
#data_cleaned %>% 
#   tabyl(title) %>% adorn_pct_formatting() %>% arrange(desc(n))

# next payment date
# commented to avoid unnecessary processing
#data_cleaned %>% 
#   tabyl(next_pymnt_d) %>% adorn_pct_formatting() %>% arrange(desc(n))

# commented to avoid unnecessary processing
#data_cleaned %>% 
#   tabyl(last_credit_pull_d) %>% adorn_pct_formatting() %>% arrange(desc(n))

data_cleaned %>% 
   tabyl(application_type) %>% 
   adorn_pct_formatting() %>% 
   arrange(desc(n))

##  application_type      n percent
##        INDIVIDUAL 274385  100.0%
##             JOINT      6    0.0%

# last payment date
# commented to avoid unnecessary processing
#data_cleaned %>% 
# tabyl(last_pymnt_d) %>% adorn_pct_formatting() %>% rrange(desc(n))

Obs: mantive as variáveis com mais categorias comentadas para evitar processamento desnecessário e que o output da execução transforme este texto em uma enciclopédia.

Grupo 3 — Variáveis sem informações

Este é para mim o único problema com esta base de dados, a falta de um dicionário de dados que indique a função de cada variável e os possíveis valores que podem ser armazenados em cada uma.

Dentro da análise de variáveis categóricas 3 delas não possuem qualquer indicador do que sejam os valores armazenados ou seu objetivo e por isso tomei a decisão de removê-las da base

Embora gradee sub_grade indiquem o agrupamento dos empréstimos seus valores não são claros, não deixam claro o que significa cada um dos grupos.

data_cleaned %>% 
   tabyl(grade) %>% adorn_pct_formatting() %>% arrange(desc(n))

##  grade     n percent
##      B 79917   29.1%
##      C 71584   26.1%
##      D 45682   16.6%
...

data_cleaned %>% 
   tabyl(sub_grade) %>% adorn_pct_formatting() %>% arrange(desc(n))

##  sub_grade     n percent
##         B3 18852    6.9%
##         B4 17895    6.5%
##         C1 16112    5.9%
...

data_cleaned %>%  
   tabyl(initial_list_status) %>% adorn_pct_formatting() %>% arrange(desc(n))

##  initial_list_status      n percent
##                    f 193471   70.5%
##                    w  80920   29.5%

Uma vez selecionadas as variáveis que não serão utilizadas, faremos a exclusão delas:

data_cleaned =
   data_cleaned %>%
   select(
    everything(), 
    # unnecessary variables
    -issue_d, -url, -pymnt_plan, -desc, -title, 
    -earliest_cr_line,-verification_status, 
    -emp_title, -next_pymnt_d, -last_credit_pull_d, -application_type,
    -zip_code, -last_pymnt_d,
    # variables without details
    -grade, -sub_grade, -initial_list_status)

Para finalizar a análise e preparação das variáveis qualitativas é necessário um último passo, transformando-as em variáveis do tipo factor. Para isso vamos primeiro conferir quais são as variáveis texto que precisamos converter.

data_cleaned %>% 
   select_if(is.character) %>% 
   names() %>%
   reshape2::melt()

##                       value
## 1                      term
## 2                emp_length
## 3            home_ownership
## 4                   purpose
## 5                addr_state
## 6 verification_status_joint
## 7                    target

Agora vamos transformá-las em factor e utilizar o comando droplevels para que categorias não utilizadas sejam removidas.

data_cleaned = 
   data_cleaned %>% 
   mutate(across(
      .cols = c(target, emp_length, term, home_ownership, purpose, addr_state, verification_status_joint),
      .fns = as.factor)) %>% 
   droplevels()

Análise de variáveis numéricas

Uma vez analisadas as variáveis categóricas faremos o mesmo processo com as variáveis numéricas.

data_cleaned %>% 
   select_if(is.numeric) %>% 
   names() %>% 
   reshape2::melt()

##                          value
## 1                    loan_amnt
## 2                  funded_amnt
## 3              funded_amnt_inv
## 4                     int_rate
## 5                  installment
## 6                   annual_inc
## 7                          dti
## 8                  delinq_2yrs
## 9               inq_last_6mths
## 10      mths_since_last_delinq
## 11      mths_since_last_record
## 12                    open_acc
## 13                     pub_rec
## 14                   revol_bal
## 15                  revol_util
## 16                   total_acc
## 17                   out_prncp
## 18               out_prncp_inv
## 19                 total_pymnt
## 20             total_pymnt_inv
## 21             total_rec_prncp
## 22               total_rec_int
## 23          total_rec_late_fee
## 24                  recoveries
## 25     collection_recovery_fee
## 26             last_pymnt_amnt
## 27  collections_12_mths_ex_med
## 28 mths_since_last_major_derog
## 29                 policy_code
## 30            annual_inc_joint
## 31                   dti_joint
## 32              acc_now_delinq
## 33                tot_coll_amt
## 34                 tot_cur_bal
## 35                 open_acc_6m
## 36                  open_il_6m
## 37                 open_il_12m
## 38                 open_il_24m
## 39          mths_since_rcnt_il
## 40                total_bal_il
## 41                     il_util
## 42                 open_rv_12m
## 43                 open_rv_24m
## 44                  max_bal_bc
## 45                    all_util
## 46            total_rev_hi_lim
## 47                      inq_fi
## 48                 total_cu_tl
## 49                inq_last_12m

Como podemos ver são 49 variáveis numéricas na base de dados e para não alongar ainda mais este texto, vou resumir o trabalho que fiz nos bastidores. Seguindo o exemplo anterior eu separei as variáveis numéricas em dois grupos:

Grupo 1 — Variáveis que mantidas como estão

As variáveis mantidas apresentam valores que podem auxilar o modelo na tarefa de predição.

# number of open credit lines in the borrower's credit file.
# data_cleaned %>% tabyl(open_acc) %>% adorn_pct_formatting() %>% arrange(desc(n))

# number of open trades in last 6 months
# data_cleaned %>% tabyl(open_acc_6m) %>% adorn_pct_formatting() %>% arrange(desc(n))

# number of negative public records (like loans that won´t granted)
# data_cleaned %>% tabyl(pub_rec) %>% adorn_pct_formatting() %>% arrange(desc(n))

# The number of months since the last public record.
# data_cleaned %>% tabyl(mths_since_last_record) %>% adorn_pct_formatting() %>% arrange(desc(n))

# data_cleaned %>% tabyl(mths_since_rcnt_il) %>% adorn_pct_formatting() %>% arrange(desc(n))

# data_cleaned %>% tabyl(mths_since_last_major_derog) %>% adorn_pct_formatting() %>% arrange(desc(n))

# total collection amounts ever owed
# data_cleaned %>% tabyl(tot_coll_amt) %>% adorn_pct_formatting() %>% arrange(desc(n))

# total current balance of all accounts
# data_cleaned %>% tabyl(tot_cur_bal) %>% adorn_pct_formatting() %>% arrange(desc(n))

# Total current balance of all installment accounts
# data_cleaned %>% tabyl(total_bal_il) %>% adorn_pct_formatting() %>% arrange(desc(n))

# Number of finance trades
# data_cleaned %>% tabyl(total_cu_tl) %>% adorn_pct_formatting() %>% arrange(desc(n))

# Number of collections (recoveries) in 12 months excluding medical collections
# data_cleaned %>% tabyl(collections_12_mths_ex_med) %>% adorn_pct_formatting() %>% arrange(desc(n))

# Number of currently active installment trades
# data_cleaned %>% tabyl(open_il_6m) %>% adorn_pct_formatting() %>% arrange(desc(n))

# Number of installment accounts opened in past 12 months
# data_cleaned %>% tabyl(open_il_12m) %>% adorn_pct_formatting() %>% arrange(desc(n))

# Number of installment accounts opened in past 24 months
# data_cleaned %>% tabyl(open_il_24m) %>% adorn_pct_formatting() %>% arrange(desc(n))

# Number of revolving trades opened in past 12 months
# data_cleaned %>% tabyl(open_rv_12m) %>% adorn_pct_formatting() %>% arrange(desc(n))

# Number of revolving trades opened in past 24 months
# data_cleaned %>% tabyl(open_rv_24m) %>% adorn_pct_formatting() %>% arrange(desc(n))

# balance to credit limit on all trades
# data_cleaned %>% tabyl(all_util) %>% adorn_pct_formatting() %>% arrange(desc(n))

# The number of accounts on which the borrower is now delinquent.
# data_cleaned %>% tabyl(acc_now_delinq) %>% adorn_pct_formatting() %>% arrange(desc(n))

# Ratio of: total current balance to high credit / credit limit on all installment acct
# data_cleaned %>% tabyl(il_util) %>% adorn_pct_formatting() %>% arrange(desc(n))

# Maximum current balance owed on all revolving accounts
# data_cleaned %>% tabyl(max_bal_bc) %>% adorn_pct_formatting() %>% arrange(desc(n))

Obs: Como estas variáveis podem possuir muitos valores eu as mantive comentadas para evitar processamento e output desnecessários

Para estas variáveis ainda é necessário um segundo passo! Muitas possuem valores em branco o que não é permitido em random forests e por isso é necessário transformar os valores nulos em zero.

data_cleaned = 
   data_cleaned %>% 
   mutate(
      open_acc = ifelse(is.na(open_acc), 0, open_acc),
      open_acc_6m = ifelse(is.na(open_acc_6m), 0, open_acc_6m),
      pub_rec = ifelse(is.na(pub_rec), 0, pub_rec),
      mths_since_last_record = ifelse(is.na(mths_since_last_record), 0, mths_since_last_record),
      mths_since_rcnt_il = ifelse(is.na(mths_since_rcnt_il), 0, mths_since_rcnt_il),
      mths_since_last_major_derog = ifelse(is.na(mths_since_last_major_derog), 0, mths_since_last_major_derog),
      tot_coll_amt = ifelse(is.na(tot_coll_amt), 0, tot_coll_amt),
      tot_cur_bal = ifelse(is.na(tot_cur_bal), 0, tot_cur_bal),
      total_bal_il = ifelse(is.na(total_bal_il), 0, total_bal_il),
      total_cu_tl = ifelse(is.na(total_cu_tl), 0, total_cu_tl),
      collections_12_mths_ex_med = ifelse(is.na(collections_12_mths_ex_med), 0, collections_12_mths_ex_med),
      open_il_6m = ifelse(is.na(open_il_6m), 0, open_il_6m),
      open_il_12m = ifelse(is.na(open_il_12m), 0, open_il_12m),
      open_il_24m = ifelse(is.na(open_il_24m), 0, open_il_24m),
      open_rv_12m = ifelse(is.na(open_rv_12m), 0, open_rv_12m),
      open_rv_24m = ifelse(is.na(open_rv_24m), 0, open_rv_24m),
      all_util = ifelse(is.na(all_util), 0, all_util),
      acc_now_delinq = ifelse(is.na(acc_now_delinq), 0, acc_now_delinq),
      il_util = ifelse(is.na(il_util), 0, il_util),
      max_bal_bc = ifelse(is.na(max_bal_bc), 0, max_bal_bc)
   )

Grupo 2 — Variáveis que serão removidas

Estas variáveis possuem valores que não contribuem para a análise por serem esparsos ou por se referirem a passos do processo de concessão do empréstimo que não impacta no processo de predição.

# Total revolving high credit/credit limit - could be removed
# data_cleaned %>% tabyl(total_rev_hi_lim) %>% adorn_pct_formatting() %>% arrange(desc(n))

# values received, because this variable is used after the loan aproval, could be removed
# data_cleaned %>% tabyl(total_pymnt) %>% adorn_pct_formatting() %>% arrange(desc(n))
# data_cleaned %>% tabyl(total_pymnt_inv) %>% adorn_pct_formatting() %>% arrange(desc(n))

# total interest received, because this variable is used after the loan aproval, could be removed
# data_cleaned %>% tabyl(total_rec_int) %>% adorn_pct_formatting() %>% arrange(desc(n))

# Late fees received to date, because this variable is used after the loan aproval, could be removed
# data_cleaned %>% tabyl(total_rec_late_fee) %>% adorn_pct_formatting() %>% arrange(desc(n))

# Principal received to date, because this variable is used after the loan aproval, could be removed
# data_cleaned %>% tabyl(total_rec_prncp) %>% adorn_pct_formatting() %>% arrange(desc(n))

# Remaining outstanding principal for total amount funded, could be removed
# data_cleaned %>% tabyl(out_prncp) %>% adorn_pct_formatting() %>% arrange(desc(n))

# Remaining outstanding principal for portion of total amount funded by investors, could be removed
# data_cleaned %>% tabyl(out_prncp_inv) %>% adorn_pct_formatting() %>% arrange(desc(n))

# values charged when the bank recover a loan that whasn´t payed, could be removed
# data_cleaned %>% tabyl(recoveries) %>% adorn_pct_formatting() %>% arrange(desc(n))
# data_cleaned %>% tabyl(collection_recovery_fee) %>% adorn_pct_formatting() %>% arrange(desc(n))

# Last total payment amount received, could be removed
# data_cleaned %>% tabyl(last_pymnt_amnt) %>% adorn_pct_formatting() %>% arrange(desc(n))

# that variable have the save value for all dataset, could be removed
# data_cleaned %>% tabyl(policy_code) %>% adorn_pct_formatting() %>% arrange(desc(n))

# The number of inquiries in past 6 months (excluding auto and mortgage inquiries)
# because are a lack of information about that varible it will be removed
# data_cleaned %>% tabyl(inq_last_6mths) %>% adorn_pct_formatting() %>% arrange(desc(n))
# data_cleaned %>% tabyl(inq_fi) %>% adorn_pct_formatting() %>% arrange(desc(n))
# data_cleaned %>% tabyl(inq_last_12m) %>% adorn_pct_formatting() %>% arrange(desc(n))

Obs: Como estas variáveis podem possuir muitos valores eu as mantive comentadas para evitar processamento e output desnecessários

Para fazer a remoção delas utilizei o comando abaixo

data_cleaned = 
   data_cleaned %>%
   select(everything(), 
          -funded_amnt, -funded_amnt_inv, -installment, -dti, -inq_last_6mths, -mths_since_last_delinq, -total_rev_hi_lim, -total_pymnt, -total_pymnt_inv, -total_rec_int, -total_rec_prncp, -total_rec_late_fee, -total_rec_late_fee, -out_prncp, -out_prncp_inv, -recoveries, -collection_recovery_fee, -dti_joint, -last_pymnt_amnt, -policy_code, -annual_inc_joint, -inq_fi, -inq_last_12m
   ) %>%
   drop_na()

Exploração dos dados

Vamos verificar algumas informações da base final, como a distribuição dos empréstimos de acordo com a variável target:

ggplot(
   data_cleaned %>% group_by(target) %>% summarise(n = n()), 
   aes(x = reorder(target, (n)), y = n, fill = target)) +
geom_bar(stat = "identity") +
geom_label(aes(label = n), hjust = 1.2, size = 3) +
scale_colour_viridis_d() +
coord_flip() +
labs(title = 'Volume per loan status', x = "Loan Status", y = "Volume") +
theme(legend.title = element_blank(),
      panel.border = element_rect(NA),
      panel.grid = element_blank(),
      panel.background = element_rect("white"),
      legend.position = "none",
      axis.text.x = element_text(angle = 90),
      strip.background =  element_rect(colour="black", size = 0.5),
      strip.text = element_text(size = 10, color="black", face = "bold"))

Podemos ver que 66 mil empréstimos (~24% do total) tiveram algum problema com o pagamento.

Dentre as variáveis categóricas preservadas temos a que indica o propósito do empréstimo. Ela pode ajudar a entender quais motivadores são mais propensos a eventuais problemas com pagamento.

ggplot(
   data_cleaned %>% 
      group_by(target, purpose) %>% 
      summarise(n = n()), 
   aes(x = reorder(purpose, (n)), y = n, fill = target)) +
   geom_bar(stat = "identity") +
   geom_label(aes(label = n), hjust = 1.2, size = 3) +
   scale_colour_viridis_d() +
   coord_flip() +
   labs(title = 'Loans per purpose', x = "Purpose", y = "Volume") +
   theme(legend.title = element_blank(),
         panel.border = element_rect(NA),
         panel.grid = element_blank(),
         panel.background = element_rect("white"),
         legend.position = "none",
         axis.text.x = element_text(angle = 90),
         strip.background =  element_rect(colour="black", size = 0.5),
         strip.text = element_text(size = 10, color="black", face = "bold"))

Como podemos observar, empréstimos com o propósito debt_consolidation apresenta a maior incidência de empréstimos com problemas de pagamento.

Preparação dos dados para o modelo

Uma vez que os dados foram tratados e “limpos” podemos prepará-los para executarmos nossa random forest. Este passo embora simples, é fundamental para continuarmos. Ele pode ser separado em 3 etapas:

1. Separação dos dados de treino e teste: para isso eu utilizei o comando sample.split do pacote caTools. Ele irá criar uma lista de valores booleanos para cada empréstimo de nossa base. Aleatoriamente irá indicar qual será deles será utilizado em nossa base de treino, que terá 80% dos dados. Ela irá utilizar como base a coluna target, para garantir que tenha uma distribuição uniforme para teste e treino
2. Criação da base de treino: utilizando a lista criada anteriormente faremos uma cópia dos dados de treino para um dataset separado
3. Criação da base de teste: esta base será utilizada para validar o modelo que criamos

train_sample = caTools::sample.split(
   data_cleaned$target, 
   SplitRatio = .80)

train_data = subset(data_cleaned, train_sample == T)
test_data  = subset(data_cleaned, train_sample == F)

O próximo passo é avaliar a base de dados para identifica quais são os melhores parâmetros para nosso modelo. Para isso utilizei o comando tuneRF do pacote randonForests. Ele irá avaliar a taxa de acerto de diferentes combinações das variáveis de nossa base até encontrar aquela que apresenta a melhor taxa.

mtry = 
   randomForest::tuneRF(
      #list of variables that will be used, in this case all but target
      train_data %>% select(-target), 
      # the information that we want to predict
      train_data$targe, 
      # number of trees that should be evaluated 
      ntreeTry=300,
      stepFactor=1.5,
      improve=0.01)

## mtry = 5  OOB error = 23.89% 
## Searching left ...
## mtry = 4     OOB error = 23.97% 
## -0.003454528 0.01 
## Searching right ...
## mtry = 7     OOB error = 23.93% 
## -0.001698635 0.01

Agora podemos iniciar a execução de nosso modelo. Não vou entrar em detalhes aqui sobre random forests, por isso deixo o link para um outro texto que escrevi sobre o tema e falo com um pouco mais de detalhes no Blog Medium

model = 
   randomForest::randomForest(
      # a fórmula da árvore, a informação de ataque cardíaco (stroke) em função de todas as variáveis de nossa base de dados
      formula = target ~ .,
      # a base de treino com xxxx registros
      data = train_data, 
      # quantidade de colunas que serão utilizadas em cada árvore
      mtry = 5,
      # quantidade de árvores que devem ser criadas pelo algorítmo 
      ntree=300)

Vamos verificar quais foram as variáveis que geraram a menor quantidade de erros durante a execução do modelo.

randomForest::varImpPlot(model, sort = T, )

Podemos ver que as variáveis addr_state e int_rate foram as mais relevantes, enquanto open_li_24 e open_li_12 não geraram impacto sobre o resultado.

Conferindo o resultado

O próximo passo agora é adicionar em nossa base de teste uma coluna com o resultado predito pelo nosso modelo, para que possamos compará-la com o resultado real.

test_data$rf_prediction = 
    predict(model, test_data, type = “class”)

Vamos criar uma matriz de confusão para visualizarmos o resultado predito

confusion_table = 
   as.data.frame(
      table(
         real = test_data$loan_status, 
         predicted = test_data$rf_prediction)
   ) %>%
   mutate(`*` = ifelse(real == predicted, '*', '')) %>%
   left_join(test_data %>%
                group_by(real = loan_status) %>%
                summarise(n_real = n()), by="real") %>%
   arrange(real)

Agora vejamos o resultado:

confusion_table %>%
   filter(`*` == '*') %>%
   mutate(acuracy = ifelse(
      Freq == 0, 
      0, 
      round((Freq / n_real) * 100, 2))) %>%
   select(real, Freq, n_real, acuracy)

         real   Freq  n_real  acuracy
1  Bad borrow    675   13321     5.07
2 Good borrow  41074   41514    98.94

Vamos conferir a acurácia do modelo, ou seja, o percentual geral de acerto:

confusion_table %>%
   mutate(correct_prediction = ifelse(
      real == predicted, 
      Freq, 
      0)) %>%
   summarise(total = sum(Freq),
             correct = sum(correct_prediction)) %>%
   mutate(acuracy = correct / total)

#  total  correct   accuracy
#1 54835    41749  0.7613568

Combinando as duas informações podemos ver que de forma geral o modelo foi capaz de acertar 76% dos 54 mil empréstimos, porém ele erra mais ao tentar prever maus pagadores, apenas 5% dos empréstimos foram indicados corretamente. Já na previsão de bons pagadores, o modelo foi capaz de acertar ~99% de todos os empréstimos!

Conclusões

Vimos que o modelo possui uma acurácia interessante, sendo muito bom em dizer se a pessoa irá pagar o empréstimo até o final, mas apresenta algumas falhas ao prever aqueles que não irão pagá-lo.

Para encerrar, o que eu acho bacana em data science é que ela não se trata apenas de criar modelos matemáticos, existe um universo inteiro de análise de dados e compreensão do problema que se deseja resolver. Por exemplo neste caso, eu poderia chegar à conclusão de que uma regressão logística seria suficiente para resolver esta necessidade de prever se aquela pessoa irá ou não pagar seu empréstimo até o final.

Caso encontre alguma canelada ou um falha no código por favor entre em cotnato comigo através do e-mail marcosmhs@live.com e ficarei feliz em fazer os ajustes necessários e colocá-lo(a) como co-autor.

Introdução

Este exemplo demostra como realizar classificação de dados estruturados à partir de um arquivo CSV. As informações incluem dados numéricos e categóricos. Será utilizada a biblioteca Keras para o processamento das informações e normalização dos dados numéricos e transformação dos dados categóricos em vetores.

Para este exemplo é necessário o uso do TensorFlow 2.5 ou superior

O Dataset

Os dados são disponibilizados pelo Cleveland Clinic Foundation for Heart Disease em um arquivo um arquivo CSV com 303 linhas, sendo que cada linha possui informações sobre um paciente (amostra). Utilizaremos estes dados para prevermos se um paciente teve ou não problema no coração.

Descrição das colunas

import tensorflow as tf
import numpy as np
import pandas as pd
from tensorflow import keras
from tensorflow.keras import layers

dados = pd.read_csv(“heart.csv")

Rápida visualização da estrutura do dataframe

dados.shape
dados.head()

Separação dos dados em treino e teste

dados_treino = dados.sample(frac=0.75, random_state=1337)
dados_teste = dados.drop(dados_treino.index)

print("Usando %d amostras para treino e %d para testar a acurácia do modelo"% (len(dados_treino), len(dados_teste)))

____

Usando 227 amostras para treino e 76 para testar a acurácia do modelo

Para utilização do tensor flow é necessário transformar os dataframes de treino e teste me objetos do tipo tf.data.Dataset.

def dataframe_para_dataset(df):
  df = df.copy()
  # extrai apenas a variável Y (target)
  labels = df.pop("target")
  ds = tf.data.Dataset.from_tensor_slices((dict(df), labels))
  ds = ds.shuffle(buffer_size=len(df))
  return ds

treino_ds = dataframe_para_dataset(dados_treino)
teste_ds = dataframe_para_dataset(dados_teste)

Cada Dataset armazena um conjunto (input e target) onde input é a lista de variáveis utilizadas para predição e target armazena o valor 0 ou 1 da variável resposta (y)

Agora vamos agrupar os dados em lotes de 32 linhas, passo importante para o uso do tensor flow

treino_ds = treino_ds.batch(32)
teste_ds = teste_ds.batch(32)

Pré-processamento dos dados com Keras

As variáveis abaixo são categóricas, porém estão armazenadas como números inteiros:

• sex
• cp
• fbs
• restecg
• exang
• ca

Precisamos transformar estas variáveis utilizando o método one-hot encoding onde cada valor único da variável se transforma em uma coluna binária indicando 1 para a existência daquele valor e 0 para sua ausência. Este método é o mesmo que a transformação de variáveis categóricas em variáveis dummy.

Neste caso faremos os seguintes passos:

- Utilizaremos o método CategoryEncoding(), que precisa saber a quantidade de valores únicos de cada variável.

- Em seguida utilizaremos o método IntegerLookup() que cria uma tabela de referência para os valores selecionados anteriormente.

Para este exemplo, nós seguiremos uma solução simples que lidará com os valores inteiros, por isso seguiremos com o método IntegerLookup()

Também temos uma variável do tipo texto `thal`. Para ela usaremos o método StringLookup() para a criação das colunas de classificação

Por fim, temos as variáveis numéricas:

• age
• trestbps
• chol
• thalach
• oldpeak
• slope

Para elas utilizaremos o método Normalization() que fará a padronização dos valores em uma faixa entre 0 e 1

Abaixo definimos a criação de 2 métodos para o tratamento dos valores:

• normalizacao_variavel_numericas responsável pela normalização dos valores numéricos
• transformacao_variavel_categorica responsável pela aplicação do método one-hot endoding nas categóricas, utilizando o parâmetro string para indicar se a variável em questão é texto ou numérica

from tensorflow.keras.layers import IntegerLookup
from tensorflow.keras.layers import Normalization
from tensorflow.keras.layers import StringLookup

def normalizacao_variavel_numericas(variavel, nome, ds):
  normalizer = Normalization()

  # Separa apenas a variável que será normalizada
  variavel_ds = ds.map(lambda x, y: x[nome])
  variavel_ds = variavel_ds.map(lambda x: tf.expand_dims(x, -1))

  # Calcula o índice dos dados para normalização
  normalizer.adapt(variavel_ds)

  # Normalização da variável e retorno
  variavel_normalizada = normalizer(variavel)
  return variavel_normalizada

def transformacao_variavel_categorica(variavel, nome, ds, string):
  # Separa a classe de acordo com o tipo da variável
  if (string):
    lookup_class = StringLookup
  else:
    lookup_class = IntegerLookup
    
  # cria a tabela de referência que irá transformar as strings em íncides númericos
  tabela_referencia = lookup_class(output_mode="binary")

  # Separa apenas a coluna alvo do dataset
  variavel_ds = ds.map(lambda x, y: x[nome])
  variavel_ds = variavel_ds.map(lambda x: tf.expand_dims(x, -1))

  # Obtem a lista de valores únicos e atribui para cada um um valor numérico
  tabela_referencia.adapt(variavel_ds)

  # transforma o valor string em valor numérico
  encoded_feature = tabela_referencia(variavel)
  return encoded_feature

Construção do modelo

Primeiramente iremos construir a estrutura de entrada, ou seja, quais variáveis devem ser informadas e qual o tipo de cada uma.

# Categorical features encoded as integers
sex      = keras.Input(shape=(1,), name="sex"    , dtype="int64")
cp       = keras.Input(shape=(1,), name="cp"     , dtype="int64")
fbs      = keras.Input(shape=(1,), name="fbs"    , dtype="int64")
restecg  = keras.Input(shape=(1,), name="restecg", dtype="int64")
exang    = keras.Input(shape=(1,), name="exang"  , dtype="int64")
ca       = keras.Input(shape=(1,), name="ca"     , dtype="int64")

# Categorical feature encoded as string
thal     = keras.Input(shape=(1,), name="thal"   , dtype="string")

# Numerical features
age      = keras.Input(shape=(1,), name="age")
trestbps = keras.Input(shape=(1,), name="trestbps")
chol     = keras.Input(shape=(1,), name="chol")
thalach  = keras.Input(shape=(1,), name="thalach")
oldpeak  = keras.Input(shape=(1,), name="oldpeak")
slope    = keras.Input(shape=(1,), name="slope")

all_inputs = [sex, cp, fbs, restecg, exang, ca, thal, age, trestbps, chol, thalach, oldpeak, slope,]

Agora indicaremos ao modelo que topo de transformação deve ser feita com os dados que forem inseridos.

# Integer categorical features
sex_encoded      = transformacao_variavel_categorica(sex, "sex", treino_ds, False)
cp_encoded       = transformacao_variavel_categorica(cp, "cp", treino_ds, False)
fbs_encoded      = transformacao_variavel_categorica(fbs, "fbs", treino_ds, False)
restecg_encoded  = transformacao_variavel_categorica(restecg, "restecg", treino_ds, False)
exang_encoded    = transformacao_variavel_categorica(exang, "exang", treino_ds, False)
ca_encoded       = transformacao_variavel_categorica(ca, "ca", treino_ds, False)

# String categorical features
thal_encoded     = transformacao_variavel_categorica(thal, "thal", treino_ds, True)

# Numerical features
age_encoded      = normalizacao_variavel_numericas(age, "age", treino_ds)
trestbps_encoded = normalizacao_variavel_numericas(trestbps, "trestbps", treino_ds)
chol_encoded     = normalizacao_variavel_numericas(chol, "chol", treino_ds)
thalach_encoded  = normalizacao_variavel_numericas(thalach, "thalach", treino_ds)
oldpeak_encoded  = normalizacao_variavel_numericas(oldpeak, "oldpeak", treino_ds)
slope_encoded    = normalizacao_variavel_numericas(slope, "slope", treino_ds)

all_features = layers.concatenate([
    sex_encoded,
    cp_encoded,
    fbs_encoded,
    restecg_encoded,
    exang_encoded,
    slope_encoded,
    ca_encoded,
    thal_encoded,
    age_encoded,
    trestbps_encoded,
    chol_encoded,
    thalach_encoded,
    oldpeak_encoded,
])

Por fim vamos configurar a rede neural, ela terá apenas 2 camadas, uma de entrada e uma de saída.

- camada de entrada: Ela irá receber dados em lotes de 32 em 32 registros, seguindo o mesmo padrão que adotamos para a separação dos lotes de dados de treino e teste. Para a rede indicar se um neurônio deve ou não ser ativado utilizaremos a função `relu`, uma das mais comuns em redes neurais.

- cama de saída: a camada de saída irá trabalhar com apenas uma unidade de saída, neste caso o % de ocorrer ou não o problema no coração e para isso usaremos a função de ativação `sigmoide` que tenta “empurrar” o valor predito para os extemos possíveis da variável Y, neste caso o mais perto possível de 0 ou 1.

Para ler mais sobre função de ativação recomendo Deep learning Book

camada_entrada = layers.Dense(units=32, activation="relu")(all_features)
camada_entrada = layers.Dropout(0.5)(camada_entrada)

camada_saida = layers.Dense(units=1, activation="sigmoid")(camada_entrada)

modelo = keras.Model(all_inputs, camada_saida)

modelo.compile("adam", "binary_crossentropy", metrics=["accuracy"])

Um exemplo de como ficará nossa rede neural

Com o modelo devidamente configurado para receber os dados de treino informaos à ele:

• x: dados de treino do modelo, por utilizarmos um objeto do tipo `tf.data.dataset` não precisamos informar a variável resposta `y` já que ela está incorporada em nosso dataset
• epochs: número de iterações entre os dados que será executado pela rede neural, neste caso ela fará 20 iterações com dados diferentes entre cada uma para encontrar a máxima acurácia.
• validation_data: dados de teste que rede neural irá utilizar para validar a acurácia do modelo à cada iteração (epoch).

modelo.fit(
  x=treino_ds,
  epochs=20,
  validation_data=teste_ds
)

Ao final da execução o modelo chegou em 85,5% de assertividade!

Teste do modelo

Utilizaremos como exemplo um paciente que sabemos que possui um problema do coração

dados[dados['target'] == 1].head()

A rede neural não indica se a pessoa terá ou não um problema cardíaco, mas sim a probabilidade de ela possuir este problema. Neste caso as chances são de 73,6%

teste = {
    "age": 67,
    "sex": 1,
    "cp": 4,
    "trestbps": 160,
    "chol": 286,
    "fbs": 0,
    "restecg": 2,
    "thalach": 108,
    "exang": 1,
    "oldpeak": 1.5,
    "slope": 2,
    "ca": 3,
    "thal": "normal",
}

input_dict = {
    name: tf.convert_to_tensor([value]) for name, 
    value in teste.items()
}
    
predicao = modelo.predict(input_dict)

print(
    "Esta pessoa possui uma probabilidade de %.1f porcento de ter um problema do coração de acordo com o modelo." 
    % (100 * predicao[0][0],)
)

### 
Esta pessoa possui uma probabilidade de 73.6 porcento de ter um problema do coração de acordo com o modelo.

Pegando como base agora um paciente que sabemos que não possui problemas cardíacos, vemos que as chances de desenvolver algo sério de acordo com o modelo é de 49,7%

dados[dados['target'] == 0].head()

teste = {
    "age": 63,
    "sex": 1,
    "cp": 1,
    "trestbps": 145,
    "chol": 233,
    "fbs": 1,
    "restecg": 2,
    "thalach": 150,
    "exang": 0,
    "oldpeak": 2.3,
    "slope": 3,
    "ca": 0,
    "thal": "fixed",
}

input_dict = {
    name: tf.convert_to_tensor([value]) for name, 
    value in teste.items()}
    
predicao = modelo.predict(input_dict)

print(
    "Esta pessoa possui uma probabilidade de %.1f porcento de ter um problema do coração de acordo com o modelo" 
    % (100 * predicao[0][0],)
)

####
Esta pessoa possui uma probabilidade de 49.7 porcento de ter um problema do coração de acordo com o modelo

Os códigos utilizados aqui podem ser acessos em
marcosmhs/Heart-Disease-Cleveland (github.com)

Uma rápida introdução

O texto de hoje é sobre uma outra forma de criar um modelo capaz de “prever” um resultado baseado em dados. Meus últimos dois textos abordaram formas de criar redes neurais e como usá-las para prever resultados: Rede neural recorrente para identificação de dígitos e Rede LSTM para predição da cotação do dólar.

Hoje trago uma outra abordagem, tão importante quanto as redes neurais e capaz de criar resultados mais claros!

Imagine que você gostaria de avaliar qual seria o resultado de sua empresa usando por exemplo a nota do NPS que suas lojas (ou loja) recebeu. Para lhe ajudar com este cálculo você possui uma base de dados com registros históricos, acumulando as vendas dos últimos 12 meses e das notas que as lojas registraram.

Se colocarmos estes dados em um gráfico do excel com receita no eixo X e NPS no eixo Y, teremos o seguinte resultado:

Cada ponto preto representa o cruzamento de resultado e NPS de uma loja e a linha azul é a reta de regressão, uma linha que tenta passar o mais próximo possível de todos os pontos, numa tentativa de resumir o gráfico a uma só informação.

Um modelo de regressão tenta estimar qual seria a reta para dados que não estão em sua base, usando apenas as informações existentes. Por exemplo, qual será a receita de uma loja se ela tiver uma nota NPS 87,8?

A fórmula base para explicar um modelo de regressão linear com base neste exemplo seria:

Y = γ0 + NPS1∗γ1 + ϵY

Onde :

• γ0(gama 0) representa uma a média da variável resposta
• γ1 (gama 1) representa a participação do NPS na inclinação da reta de regressão
• ϵ (epsilon) representa a distância entre o valor real da receita e o valor que foi previsto pelos termos γ1γ1, este valor também é chamado de erro ou resíduo

O desafio neste tipo de modelo é encontrar os valores de γ0γ0 e γ1γ1para que possamos substituí-los em nossa fórmula e encontrar o valor da receita.

E quando o mundo não é linear? E quase sempre não é!

A modelagem linear cumpre bem o seu papel em determinados cenários, mas em muitos casos ela sozinha não é suficiente para explicar um mundo tão diverso. E é aí que entra a modelagem multinível! Um modelo que prevê que o mundo é feito de grupos e que estes grupos exercem influência sobre os dados. Este modelo considera que os dados podem ser agrupados em até três níveis:

Onde:

• Grupo 1 (t), podemos trabalhar com uma escala de tempo, por exemplo, se houver dados de minha loja segmentados por mês;
• Grupo 2 (i), temos o indivíduo, no nosso exemplo a loja;
• Grupo 3 (j) temos o agrupamento, neste caso a cidade.

Neste cenário podemos avaliar que as lojas podem ter comportamento diferente dependendo da cidade onde estão localizadas e que variáveis específicas destas cidades podem influenciar em seu resultado, além do NPS.

Neste caso trabalharemos com os grupos i e j apenas, respectivamente os níveis 1 (loja) e 2 (cidade).

Preparação dos pacotes

pacotes = c("plotly","tidyverse","reshape2","knitr","kableExtra","rgl","car", "nlme","lmtest","fastDummies","msm","lmeInfo","jtools", "data.table", "olsrr")

if(sum(as.numeric(!pacotes %in% installed.packages())) != 0){
  instalador <- pacotes[!pacotes %in% installed.packages()]
  for(i in 1:length(instalador)) {
    install.packages(instalador, dependencies = T)
    break()}
  sapply(pacotes, require, character = T) 
} else {
  sapply(pacotes, require, character = T) 
}

A função stderr_nlme, de autoria dos professores Fávero e Rafael Sousa ajuda a identificar a significância estatística dos dados de cada nível e de certa forma a calcular o quanto do comportamento dos dados é explicado por cada nível.

stderr_nlme <- function(model){
  if(base::class(model) != "lme"){
    base::message("Use a lme object model from nlme package")
    stop()}
  resume <- base::summary(model)
  if(base::length(base::names(model$groups))==1){
    m.type <- "HLM2"
  } else if(base::length(base::names(model$groups))==2){
    m.type <- "HLM3"
  }
  if(m.type == "HLM2"){
    vcov_matrix <- model$apVar
    logs_sd_re <- base::attr(vcov_matrix,"Pars")
    if(base::length(logs_sd_re)==2){
      stderr_tau00 <- msm::deltamethod(~exp(x1)^2,logs_sd_re,vcov_matrix)
      stderr_sigma <- msm::deltamethod(~exp(x2)^2,logs_sd_re,vcov_matrix)
      results <- base::data.frame(`RE Components`=base::c("Var(v0j)","Var(e)"),
                                  `Variance Estimatives`= base::c(base::exp(logs_sd_re)[[1]]^2,
                                                                  base::exp(logs_sd_re[[2]])^2),
                                  `Std Err.`=base::c(stderr_tau00,
                                                     stderr_sigma),
                                  z=base::c(base::exp(logs_sd_re)[[1]]^2/stderr_tau00,
                                            base::exp(logs_sd_re[[2]])^2/stderr_sigma),
                                  `p-value`=base::round(stats::pnorm(q=base::c(base::exp(logs_sd_re)[[1]]^2/stderr_tau00,
                                                                               base::exp(logs_sd_re[[2]])^2/stderr_sigma),
                                                                     lower.tail=F)*2,3))
      return(results)
    }
    else{
      stderr_tau00 <- msm::deltamethod(~exp(x1)^2,logs_sd_re,vcov_matrix)
      stderr_tau01 <- msm::deltamethod(~exp(x2)^2,logs_sd_re,vcov_matrix)
      stderr_sigma <- msm::deltamethod(~exp(x4)^2,logs_sd_re,vcov_matrix)
      results <- base::data.frame(Components=base::c("Var(v0j)","Var(v1j)","Var(e)"),
                                  `Variance Estimatives`= base::c(base::exp(logs_sd_re)[[1]]^2,
                                                       base::exp(logs_sd_re[[2]])^2,
                                                       base::exp(logs_sd_re[[4]])^2),
                                  `Std Err.`=base::c(stderr_tau00,
                                                  stderr_tau01,
                                                  stderr_sigma),
                                  z=base::c(base::exp(logs_sd_re)[[1]]^2/stderr_tau00,
                                            base::exp(logs_sd_re[[2]])^2/stderr_tau01,
                                            base::exp(logs_sd_re[[4]])^2/stderr_sigma),
                                  `p-value`=base::round(stats::pnorm(q=base::c(base::exp(logs_sd_re)[[1]]^2/stderr_tau00,
                                                                               base::exp(logs_sd_re[[2]])^2/stderr_tau01,
                                                                               base::exp(logs_sd_re[[4]])^2/stderr_sigma),
                                                                     lower.tail=F)*2,3))
      return(results)
    }
  }
  if(m.type == "HLM3"){
    vcov_matrix <- model$apVar
    logs_sd_re <-  base::attr(vcov_matrix,"Pars")
    if(base::length(logs_sd_re) == 3){
      stderr_tau_r000 <- msm::deltamethod(~exp(x1)^2,logs_sd_re,vcov_matrix)
      stderr_tau_u000 <- msm::deltamethod(~exp(x2)^2,logs_sd_re,vcov_matrix)
      stderr_sigma <- msm::deltamethod(~exp(x3)^2,logs_sd_re,vcov_matrix)
      results <- base::data.frame(Components=base::c("Var(t00k)","Var(v0jk)","Var(e)"),
                                  Estimatives=base::c(base::exp(logs_sd_re)[[2]]^2,
                                                      base::exp(logs_sd_re)[[1]]^2,
                                                      base::exp(logs_sd_re)[[3]]^2),
                                  Std_Err=base::c(stderr_tau_u000,
                                                  stderr_tau_r000,
                                                  stderr_sigma),
                                  z=base::c(base::exp(logs_sd_re)[[2]]^2/stderr_tau_u000,
                                            base::exp(logs_sd_re)[[1]]^2/stderr_tau_r000,
                                            base::exp(logs_sd_re)[[3]]^2/stderr_sigma),
                                  `p-value`=base::round(stats::pnorm(q=base::c(base::exp(logs_sd_re)[[2]]^2/stderr_tau_u000,
                                                                               base::exp(logs_sd_re)[[1]]^2/stderr_tau_r000,
                                                                               base::exp(logs_sd_re)[[3]]^2/stderr_sigma),
                                                                     lower.tail=F)*2,3))
      return(results)
    } 
    else{
      stderr_tau_r000 <- msm::deltamethod(~exp(x1)^2,logs_sd_re,vcov_matrix)
      stderr_tau_r100 <- msm::deltamethod(~exp(x2)^2,logs_sd_re,vcov_matrix)
      stderr_tau_u000 <- msm::deltamethod(~exp(x4)^2,logs_sd_re,vcov_matrix)
      stderr_tau_u100 <- msm::deltamethod(~exp(x5)^2,logs_sd_re,vcov_matrix)
      stderr_sigma <- msm::deltamethod(~exp(x7)^2,logs_sd_re,vcov_matrix)
      results <- base::data.frame(`RE_Components`=base::c("Var(t00k)","Var(t10k)",
                                                          "Var(v0jk)","Var(v1jk)",
                                                          "Var(e)"),
                                  `Variance Estimatives`=base::c(base::exp(logs_sd_re)[[4]]^2,
                                                                 base::exp(logs_sd_re)[[5]]^2,
                                                                 base::exp(logs_sd_re)[[1]]^2,
                                                                 base::exp(logs_sd_re)[[2]]^2,
                                                                 base::exp(logs_sd_re)[[7]]^2),
                                  `Std Err.`=base::c(stderr_tau_u000,
                                                     stderr_tau_u100,
                                                     stderr_tau_r000,
                                                     stderr_tau_r100,
                                                     stderr_sigma),
                                  z=base::c(base::exp(logs_sd_re)[[4]]^2/stderr_tau_u000,
                                            base::exp(logs_sd_re)[[5]]^2/stderr_tau_u100,
                                            base::exp(logs_sd_re)[[1]]^2/stderr_tau_r000,
                                            base::exp(logs_sd_re)[[2]]^2/stderr_tau_r100,
                                            base::exp(logs_sd_re)[[7]]^2/stderr_sigma),
                                  `p-value`=base::round(stats::pnorm(q=base::c(base::exp(logs_sd_re)[[4]]^2/stderr_tau_u000,
                                                                               base::exp(logs_sd_re)[[5]]^2/stderr_tau_u100,
                                                                               base::exp(logs_sd_re)[[1]]^2/stderr_tau_r000,
                                                                               base::exp(logs_sd_re)[[2]]^2/stderr_tau_r100,
                                                                               base::exp(logs_sd_re)[[7]]^2/stderr_sigma),
                                                                     lower.tail=F)*2,3))
      return(results)
    }
  }
}

Importação dos dados e análise exploratória

vendas = 
  fread("dados_vendas_totais_2021.csv", dec =",", sep=";") %>%
  select(cidade, loja, receita, nps, inflacao) %>%
  mutate(loja = as.factor(loja), cidade = as.factor(cidade))

Para testar o modelo vamos utilizar uma segunda base de dados semelhante à nossa base de treino (vendas) com 195 registros

teste = 
  fread("dados_para_teste.csv", dec =",", sep=";") %>%
  select(cidade, loja, receita, nps, inflacao) %>%
  mutate(loja = as.factor(loja), cidade = as.factor(cidade))

A visualização das primeiras 5 linhas das cidades 1 e 2, foi aplicado a função scalepara evitar que os dados sejam expostos

rbind(
  vendas %>% 
    filter(cidade == 1) %>% 
    filter(row_number() <= 5),
  vendas %>% 
    filter(cidade == 2) %>% 
    filter(row_number() <= 5)) %>%
  kable() %>%
  kable_styling(bootstrap_options = "striped", 
                position = "center", 
                full_width = F, 
                font_size = 14)

vendas %>% 
  group_by(cidade) %>% 
  mutate(linhas = 1:n()) %>% 
  mutate(x = unlist(density(receita, n = max(linhas))["x"]),
         y = unlist(density(receita, n = max(linhas))["y"])) %>%
  ggplot() +
  geom_area(aes(x = x, y = y, group = cidade, fill = cidade), color = "black", alpha = 0.4) +
  geom_histogram(aes(x = receita, 
                     y = ..density.., 
                     fill = cidade), 
                 color = "black", 
                 position = 'identity', 
                 alpha = 0.3) +
  facet_wrap(~ cidade) +
  scale_fill_viridis_d() +
  scale_color_viridis_d() +
  theme_classic()

vendas %>%
  ggplot() +
  geom_bar(aes(x = cidade, y=inflacao, fill = cidade), stat = "identity") +
  scale_y_continuous() +
  scale_fill_viridis_d() +
  theme_minimal()

Temos aqui os indícios necessário para iniciar a exploração de modelos de regressão!

Criação dos modelos

Para a modelagem multinível utiliza-se a técnica step-up onde o modelo é otimizado a cada execução até obter-se sua versão final. Para verificar o modelo vamos utilizar o BIC (bayesian information criterion) critério que avalia o quão perto o modelo está dados reais considerando também as variáveis explicativas.

O primeiro modelo a ser criado é o modelo nulo, que não considera nenhuma variável preditora, apenas a receita e o agrupamento por cidade. Sua fórmula pode é:

receita_ij = γ00+ν0j+ϵi

Onde:

• γ00 representa a média geral da variável receita
• ν0j representa a influência da cidade sobre a receita
• νij representa a distância entre a receita calculada para aquela observação e o valor real

Observe que todos os dados são subscritos de com i e j onde i representa o dado no nível loja e j no nível cidade.

No R a execução desta fórmula é feita pelo comando lme do pacote nlme

#fixed é a fórmula base, de regressão linear
#random é a fórmula de agrupamento dos dados, neste caso cidade
hlm_nulo = 
  lme(fixed = receita ~1, 
      random = ~1 | cidade, 
      data = vendas,
      method = "REML")

BIC(hlm_nulo)

## [1] 14212.24

O BIC de nosso modelo base é 14212.24, ele será utilizado mais adiante para compararmos o ganho dos próximos modelos. Quando menor ele for, melhor!

stderr_nlme(hlm_nulo)

##   RE.Components Variance.Estimatives  Std.Err.        z p.value
## 1      Var(v0j)             626248.2 223061.02  2.80752   0.005
## 2        Var(e)             254473.4  11949.33 21.29604   0.000

Outra informação importante vem através do método stderr_nlme, nele podemos ver que o p-value de nossa variável receita (v0j) é estatisticamente significativa (menor que 0,05), indicando que o modelo multinível é aplicável à este caso. Se ela fosse superior a 0,05 o modelo de regressão linear simples seria o mais indicado.

Utilizaremos agora a base de testes para executar nosso modelo e comparar se os resultados previstos estão próximos do resultado real.

teste$hlm_nulo_fitted = predict(hlm_nulo, teste)

teste %>%  
  ggplot() +
  geom_smooth(aes(x = receita, y = hlm_nulo_fitted),
              method = "lm", se = F, formula = y ~ splines::bs(x, df = 5),
              size = 1.5) +
  geom_smooth(aes(x = receita, y = receita), method = "lm", 
              color = "gray44", size = 1.05,
              linetype = "longdash") +
  labs(x = "Receita real", y = "Valores Preditos") +
  theme_bw()

Observe que a linha azul (modelo nulo) chega a tocar a linha pontilhada (resultado perfeito), mas apresenta considerável diferença no início e no final da reta.

Modelo com interceptos aleatórios

O próximo passo, é a modelo com interceptos aleatórios que considera apenas efeito que a cidade (intercepto) exerce sobre a receita:

receita_ij=γ00+γ10∗npsij+ν0j+ϵ_ij

Onde:

• γ00 representa a média geral da variável receita
• γ10 representa a inclinação da reta de receita de acordo com o avanço do NPS
• ν0j representa a influência da cidade sobre a receita
• ν_ij representa a distância entre a receita calculada para aquela observação e o valor real

No R a fórmula pode ser representada como no exemplo abaixo:

hlm_intercept_aleatorios = 
  lme(fixed = receita ~ nps  + inflacao,
      random = ~1 | cidade,
      data = vendas,
      method = "REML")

#observação do BIC do modelo
BIC(hlm_intercept_aleatorios)

## [1] 13421.34

O indicador BIC, que no modelo nulo, é de 14212,24 foi reduzido para 13421,35 indicando que a variável NPS possui grande efeito sobre a receita.

stderr_nlme(hlm_intercept_aleatorios)

##   RE.Components Variance.Estimatives  Std.Err.         z p.value
## 1      Var(v0j)             142365.8 52902.868  2.691079   0.007
## 2        Var(e)             110375.8  5185.945 21.283637   0.000

O p-value do nível v0j segue abaixo de 0,05 indicando que o modelo é estatisticamente significativo.

Vamos verificar agora como os modelos se aproximam do valor ideal:

teste$hlm_intercept_aleatorios_fitted = predict(hlm_intercept_aleatorios, teste)

teste %>%
  
  ggplot() +
  geom_smooth(aes(x = receita, y = hlm_nulo_fitted, color = "Modelo Nulo"),
              method = "lm", se = F, formula = y ~ splines::bs(x, df = 5),
              size = 1.5) +
  geom_smooth(aes(x = receita, y= hlm_intercept_aleatorios_fitted, color = "Interceptos Aletaórios"),
              method = "lm", se = F, formula = y ~ splines::bs(x, df = 5),
              size = 1.5) +

  geom_smooth(aes(x = receita, y = receita), method = "lm", 
              color = "gray44", size = 1.05,
              linetype = "longdash") +
  scale_color_manual("Modelos:", 
                     values = c("deepskyblue1", "maroon1")) +
  labs(x = "Receita Real", y = "Receita Prevista") +
  theme_bw()

Observe que a linha do modelo com interceptos aleatórios chegou muito perto da reta ideal

Modelo com interceptos e inclinações aleatórias

O próximo passo é verificarmos o efeito que a cidade exerce sobre o NPS e a receita e pode ser descrita pela função:

receita_ij=γ00 + γ10∗nps_ij + ν0j + ν1j∗nps_ij + ϵ_ij

Onde:

• γ00 representa a média geral da variável receita
• γ10 representa a inclinação da reta de receita de acordo com o avanço do NPS
• ν0j representa a influência da cidade sobre a receita
• νij representa a distância entre a receita calculada para aquela observação e o valor real

Observe que agora temos ν_ij influenciando o valor de NPS: ν_ij∗nps_ij

No R teremos:

hlm_intercept_inclin = 
  lme(fixed = receita ~ nps  + inflacao, 
      random = ~ nps  | cidade, 
      data = vendas,
      method = "REML")

BIC(hlm_intercept_inclin)

## [1] 13299.13

Nesta terceira execução observa-se uma nova queda no indicador BIC, mostrando que o volume de erros diminuiu em comparação com os modelos anteriores

stderr_nlme(hlm_intercept_inclin)

##   Components Variance.Estimatives    Std.Err.        z p.value
## 1   Var(v0j)          658818.6994 302905.1560  2.17500   0.030
## 2   Var(v1j)             123.7548     47.6011  2.59983   0.009
## 3     Var(e)           90701.3200   4301.1633 21.08763   0.000

O p-value do nível v0j (nível loja) e v1j seguem abaixo de 0,05 indicando que o modelo continua estatisticamente significativo.

Por fim vamos comparar a performance dos modelos

teste$hlm_intercept_inclin_fitted = 
   predict(hlm_intercept_inclin, teste)

teste %>%  
  ggplot() +
  geom_smooth(aes(x = receita, y = hlm_nulo_fitted, color = "Modelo Nulo"),
              method = "lm", se = F, formula = y ~ splines::bs(x, df = 5),
              size = 1.5) +
  geom_smooth(aes(x = receita, y= hlm_intercept_aleatorios_fitted, color = "Interceptos Aletaórios"),
              method = "lm", se = F, formula = y ~ splines::bs(x, df = 5),
              size = 1.5) +
  
  geom_smooth(aes(x = receita, y= hlm_intercept_inclin_fitted, color = "Interceptos e Inclinações aleatórias"),
              method = "lm", se = F, formula = y ~ splines::bs(x, df = 5),
              size = 1.5) +  

  geom_smooth(aes(x = receita, y = receita), method = "lm", 
              color = "gray44", size = 1.05,
              linetype = "longdash") +
  scale_color_manual("Modelos:", 
                     values = c("deepskyblue1", "maroon1", "darkorchid2")) +
  labs(x = "Receita Real", y = "Receita Prevista") +
  theme_bw()

Modelo Final

Agora que verificamos que o NPS tem efeito sobre a receita e que o agrupamento por cidade também exerce efeito sobre as demais informações, vamos verificar se as variáveis do nível de cidade, neste caso a inflação local também impacta no resultado. Teremos finalmente a fórmula completa:

receita_ij=γ00 + γ10∗nps_ij + γ01∗inflacao_j + γ11∗nps_ij∗inflacao_j + ν0j + ν1_j∗np_sij+ϵ_ij

No R teremos:

hlm_final = 
  lme(fixed = receita ~ nps  + inflacao + nps:inflacao,
      random = ~ nps | cidade,
      data = vendas,
      method = "REML")

BIC(hlm_final)

## [1] 13281.57

Observamos uma nova redução no BIC, indicando que o houve melhora no modelo ao incluir o efeito da inflação na receita e no NPS.

stderr_nlme(hlm_final)

##   Components Variance.Estimatives     Std.Err.         z p.value
## 1   Var(v0j)         392327.54923 163961.75910  2.392799   0.017
## 2   Var(v1j)             56.82155     24.49188  2.320016   0.020
## 3     Var(e)          90634.81776   4294.83656 21.103205   0.000

O p-value do nível v0j (nível loja) e v1j seguem abaixo de 0,05 ou seja, modelo significativo estatisticamente. Vamos verificar visualmente como essa nota reta se porta com a base de testes

teste$hlm_final_fitted = predict(hlm_final, teste)

teste %>%  
  ggplot() +
  geom_smooth(aes(x = receita, y = hlm_nulo_fitted, color = "1 - Modelo Nulo"),
              method = "lm", se = F, formula = y ~ splines::bs(x, df = 5),
              size = 1.5) +
  geom_smooth(aes(x = receita, y= hlm_intercept_aleatorios_fitted, color = "2 - Interceptos Aletaórios"),
              method = "lm", se = F, formula = y ~ splines::bs(x, df = 5),
              size = 1.5) +
  
  geom_smooth(aes(x = receita, y= hlm_intercept_inclin_fitted, color = "3 - Interceptos e Inclinações aleatórias"),
              method = "lm", se = F, formula = y ~ splines::bs(x, df = 5),
              size = 1.5) +  
  
  geom_smooth(aes(x = receita, y= hlm_final_fitted, color = "4 - Modelo Final"),
              method = "lm", se = F, formula = y ~ splines::bs(x, df = 5),
              size = 1.5) +  

  geom_smooth(aes(x = receita, y = receita), method = "lm", 
              color = "gray44", size = 1.05,
              linetype = "longdash") +
  scale_color_manual("Modelos:", 
                     values = c("deepskyblue1", "maroon1", "darkorchid2", "SpringGreen3")) +
  labs(x = "Receita Real", y = "Receita Prevista") +
  theme_bw()

Bônus

Vamos comparar o modelo HLM com um modelo re regressão linar, utilizando todas as técnicas necessárias para aumentar sua acuracidade:

Sabendo que temos uma variável qualitativa (a cidade) utilizaremos o método dummy_cols para transformar as colunas de forma que possam ser utilizadas em uma regressão linar. A “dumização” transformará a coluna cidade em uma série de colunas (uma para cada cidade) preenchendo seu valor com 0 ou 1 dependendo do valor da coluna original

vendas_dummies =
    dummy_cols(.data = vendas,
               select_columns = "cidade",
               remove_first_dummy = TRUE,
               remove_selected_columns = TRUE)

#16 colunas cidade foram criadas, o método dummy_cols não inclui a primeira coluna "dumizada" já que ela é a auzência de dados em todas as demais 16

Executamos o método lmpara que seja criado o modelo de regressão simples, observe que agora cada coluna cidade deve ser informado na fórmula que seria:

Y= γ0 + NPS1∗γ1 + inflacao∗γ2 + cidade1∗γ3 + cidade2∗γ4 +…+ cidaden∗γn + ϵ

No R teremos a fórmula:

ols_final_dummies =
  lm(formula = receita ~ nps + inflacao + cidade_2 + cidade_3 + cidade_4 + cidade_5 + cidade_6 + cidade_7 + cidade_8 + cidade_9 + cidade_10 + cidade_11 + cidade_12 +  cidade_13+ cidade_14+ cidade_15+ cidade_16+ cidade_17,
     data = vendas_dummies)

Ao criar variáveis dummies é necessário verificar se uma ou mais destas variáveis possuem significância estatística, para isso usamos o comando summarypara verificar o p-value de cada um, toda variável com p-value maior que 0,05 deve ser removida do modelo

summary(ols_final_dummies)

## Call:
## lm(formula = receita ~ nps + inflacao + cidade_2 + cidade_3 + 
##     cidade_4 + cidade_5 + cidade_6 + cidade_7 + cidade_8 + cidade_9 + 
##     cidade_10 + cidade_11 + cidade_12 + cidade_13 + cidade_14 + 
##     cidade_15 + cidade_16 + cidade_17, data = vendas_dummies)
## 
## Residuals:
##      Min       1Q   Median       3Q      Max 
## -2514.31  -140.56     8.63   151.16  1333.93 
## 
## Coefficients: (1 not defined because of singularities)
##               Estimate Std. Error t value Pr(>|t|)    
## (Intercept) -1.344e+04  1.083e+03 -12.412  < 2e-16 ***
## nps          2.852e+01  8.283e-01  34.426  < 2e-16 ***
## inflacao     1.270e+05  1.026e+04  12.377  < 2e-16 ***
## cidade_2     1.896e+01  1.102e+02   0.172   0.8634    
## cidade_3    -9.563e+01  1.103e+02  -0.867   0.3862    
## cidade_4    -4.043e+02  8.725e+01  -4.634 4.11e-06 ***
## cidade_5     3.096e+02  1.257e+02   2.464   0.0139 *  
## cidade_6     6.555e+01  6.813e+01   0.962   0.3362    
## cidade_7     2.746e+01  7.334e+01   0.374   0.7082    
## cidade_8    -1.934e+03  2.371e+02  -8.157 1.14e-15 ***
## cidade_9     9.821e+02  2.005e+02   4.899 1.14e-06 ***
## cidade_10   -7.141e+02  5.836e+01 -12.236  < 2e-16 ***
## cidade_11   -1.409e+02  6.263e+01  -2.249   0.0247 *  
## cidade_12    5.940e+01  1.118e+02   0.531   0.5954    
## cidade_13   -1.421e+02  1.131e+02  -1.256   0.2093    
## cidade_14   -9.191e+02  1.178e+02  -7.799 1.71e-14 ***
## cidade_15    1.874e+03  2.508e+02   7.470 1.89e-13 ***
## cidade_16    3.923e+02  8.171e+01   4.801 1.84e-06 ***
## cidade_17           NA         NA      NA       NA    
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## Residual standard error: 332.2 on 906 degrees of freedom
## Multiple R-squared:  0.8843, Adjusted R-squared:  0.8821 
## F-statistic: 407.3 on 17 and 906 DF,  p-value: < 2.2e-16

Para fazer a remoção destas variáveis podemos utilizar o método stepwise, que fará a remoção e recalculará o modelo apenas com aquelas variáveis que possuem a capacidade de explicar o modelo

ols_final_dummies_step = 
  step(object = ols_final_dummies,
       step = qchisq(p = 0.05, df = 1,lower.tail = FALSE))

## Start:  AIC=10746.98
## receita ~ nps + inflacao + cidade_2 + cidade_3 + cidade_4 + cidade_5 + 
##     cidade_6 + cidade_7 + cidade_8 + cidade_9 + cidade_10 + cidade_11 + 
##     cidade_12 + cidade_13 + cidade_14 + cidade_15 + cidade_16 + 
##     cidade_17
## 
## 
## Step:  AIC=10746.98
## receita ~ nps + inflacao + cidade_2 + cidade_3 + cidade_4 + cidade_5 + 
##     cidade_6 + cidade_7 + cidade_8 + cidade_9 + cidade_10 + cidade_11 + 
##     cidade_12 + cidade_13 + cidade_14 + cidade_15 + cidade_16
## 
##             Df Sum of Sq       RSS   AIC
## - cidade_2   1      3270 100003054 10745
## - cidade_7   1     15473 100015257 10745
## - cidade_12  1     31152 100030936 10745
## - cidade_3   1     82951 100082735 10746
## - cidade_6   1    102172 100101956 10746
## - cidade_13  1    174243 100174027 10747
## <none>                    99999784 10747
## - cidade_11  1    558331 100558114 10750
## - cidade_5   1    669874 100669658 10751
## - cidade_4   1   2370248 102370031 10767
## - cidade_16  1   2544440 102544224 10768
## - cidade_9   1   2648615 102648399 10769
## - cidade_15  1   6158538 106158321 10800
## - cidade_14  1   6714231 106714015 10805
## - cidade_8   1   7343946 107343730 10810
## - cidade_10  1  16525380 116525163 10886
## - inflacao   1  16909397 116909180 10889
## - nps        1 130813027 230812811 11518
## 
## Step:  AIC=10745.01
## receita ~ nps + inflacao + cidade_3 + cidade_4 + cidade_5 + cidade_6 + 
##     cidade_7 + cidade_8 + cidade_9 + cidade_10 + cidade_11 + 
##     cidade_12 + cidade_13 + cidade_14 + cidade_15 + cidade_16
## 
##             Df Sum of Sq       RSS   AIC
## - cidade_7   1     20346 100023400 10743
## - cidade_12  1     41780 100044834 10743
## - cidade_3   1    113279 100116333 10744
## - cidade_6   1    118867 100121921 10744
## <none>                   100003054 10745
## - cidade_13  1    284689 100287743 10746
## - cidade_11  1    603296 100606350 10749
## - cidade_5   1   2096269 102099323 10762
## - cidade_4   1   2767891 102770945 10768
## - cidade_16  1   4742302 104745356 10786
## - cidade_9   1   9452588 109455642 10826
## - cidade_14  1  10763230 110766284 10838
## - cidade_10  1  16601943 116604997 10885
## - cidade_8   1  18475157 118478211 10900
## - cidade_15  1  21443025 121446079 10922
## - inflacao   1  56343070 156346124 11156
## - nps        1 130824194 230827247 11516
## 
## Step:  AIC=10743.2
## receita ~ nps + inflacao + cidade_3 + cidade_4 + cidade_5 + cidade_6 + 
##     cidade_8 + cidade_9 + cidade_10 + cidade_11 + cidade_12 + 
##     cidade_13 + cidade_14 + cidade_15 + cidade_16
## 
##             Df Sum of Sq       RSS   AIC
## - cidade_12  1     46998 100070398 10742
## - cidade_6   1    110240 100133639 10742
## - cidade_3   1    186673 100210073 10743
## <none>                   100023400 10743
## - cidade_13  1    438006 100461406 10745
## - cidade_11  1    671247 100694647 10747
## - cidade_5   1   2230779 102254178 10762
## - cidade_4   1   3210063 103233463 10770
## - cidade_16  1   4734930 104758330 10784
## - cidade_9   1  10430538 110453938 10833
## - cidade_14  1  12824578 112847978 10853
## - cidade_10  1  18406072 118429472 10897
## - cidade_8   1  23029683 123053083 10933
## - cidade_15  1  23793717 123817117 10938
## - inflacao   1  67164122 167187522 11216
## - nps        1 130943242 230966641 11514
## 
## Step:  AIC=10741.63
## receita ~ nps + inflacao + cidade_3 + cidade_4 + cidade_5 + cidade_6 + 
##     cidade_8 + cidade_9 + cidade_10 + cidade_11 + cidade_13 + 
##     cidade_14 + cidade_15 + cidade_16

Vamos ver como ficou o BIC

BIC(ols_final_dummies_step)

## [1] 13443.09

Para finalizar vamos comparar o modelo final com o modelo OLS com variáveis dummies e stepwise:

teste_dummies =
    dummy_cols(.data = teste,
               select_columns = "cidade",
               remove_first_dummy = TRUE,
               remove_selected_columns = TRUE)

teste_dummies$cidade_2 = NULL
teste_dummies$cidade_7 = NULL
teste_dummies$cidade_12 = NULL
teste_dummies$cidade_17 = NULL

teste$ols_completo_fitted = 
   predict(ols_final_dummies_step, teste_dummies)

teste %>%
  ggplot() +
  geom_smooth(aes(x = receita, y = hlm_final_fitted, color = "1 - HLM Modelo Final"),
              method = "lm", se = F, formula = y ~ splines::bs(x, df = 5),
              size = 1.5) +
  geom_smooth(aes(x = receita, y= ols_completo_fitted, color = "2 - OLS c/ Dummies e Stepwise"),
              method = "lm", se = F, formula = y ~ splines::bs(x, df = 5),
              size = 1.5) +
  geom_smooth(aes(x = receita, y = receita), method = "lm", 
              color = "gray44", size = 1.05,
              linetype = "longdash") +
  scale_color_manual("Modelos:", 
                     values = c("deepskyblue1", "maroon1")) +
  labs(x = "Receita Real", y = "Receita Prevista") +
  theme_bw()

Conclusão

A regressão multinível é capaz de considerar melhor todas os aspectos dos dados de treino do modelo, criando um modelo capaz de prever com maior exatidão valores futuros.

Uma outra forma de verificar a qualidade do modelo é através da verificação da raiz quadrada do erro médio (RMSE em inglês), uma métrica utilizada para comparar modelos indicando sua acuracidade (quando menor seu valor melhor o resultado) e reforça a capacidade do modelo multinível em prever resultados com menor erro, neste caso ele é 5x mais eficiente que o modelo tradicional.

teste %>% 
  
  summarise(hlm = sqrt(mean((receita - hlm_final_fitted) ^ 2,na.rm = T)),
            ols = sqrt(mean((receita - ols_completo_fitted) ^ 2,na.rm = T))) %>%
  melt() %>%
  ggplot(aes(y = value, x=variable, fill = factor(variable))) +
  geom_bar(stat = "identity") + 
  geom_label(aes(label = (round(value,3))), hjust = 1.2, color = "white", size = 5) +
  coord_flip() +
  labs(title="RMSE", 
       x = "modelos",
       y = "") + 
  theme_minimal()

Infelizmente desta vez eu não posso divulgar os dados originais, mas com este mesmo código, apenas substituindo as variáveis receita, NPS, inflação e cidade é possível aplicá-la a diversos cenários de dados.

Caso encontre alguma falha nos algoritmos ou um erro no processo, por favor me avise no meu linkedin (https://www.linkedin.com/in/marcosmhs/) e ficarei feliz realizar as correções necessárias e incluí-lo neste texto.

Até a próxima!

Uma introdução sobre o time

O texto de hoje é sobre um dos modelos preditivos mais relevantes atualmente capaz de rivalizar com redes neurais complexas e que deixa muitos modelos de regressão linear no chinelo! Hoje vamos de Floretas Aleatórias! (Mais um exemplo de como a tradução direta do inglês para o português é complicado!).

Este tipo de algoritmo de machine learning se mostra excepcionalmente relevante em problemas de classificação, quando o resultado esperado não é um valor numérico, mas uma informação categórica, vulgo qualitativa.

O nome (esquisito em português) vem de sua base, as árvores de decisão, e utilizando uma série de regras de separação dos dados estas “florestas” são capazes de predições altamente acuradas.

Falando rapidamente das árvores de decisão, elas apresentam uma forma simples de classificação, separando as informações em galhos até chegar em um nível onde a informação não pode mais ser segmentada. Um exemplo lúdico, pode ser aquela brincadeira da adivinhação, onde você começa perguntando: “Sou um animal ou uma pessoa”, “Sou homem ou mulher”, “Sou uma criança ou um adulto?” e através destas perguntas você começa a estreitar as opções até chegar no melhor resultado possível, se fosse uma brinca com meu filho este resultado geralmente é Homem Aranha!

Cada pergunta desta pode ser comparada aos galhos de uma árvore de decisão e as folhas, seu nível mais baixo são as respostas possíveis. Abaixo uma representação de uma árvore de decisão olhando para os dados criada com base nos dados que exploraremos daqui a pouco!

Caso queira se aprofundar um pouco mais no tema, deixo o texto do Gabriel Stankevix aqui do blog Medium, que possui uma infinidade de conteúdos interessantes sobre data science e machine learning.

As random forests se apoiam nas árvores de decisão criando centenas de versões diferentes destas árvores com base nos dados e nas variáveis informadas. Para isso elas utilizam:

Seleção aleatória dos dados: de forma geral 2/3 dos dados informados serão selecionados de forma aleatória para serem utilizados na etapa de aprendizagem e o outro 1/3 será utilizado para validar o resultado de cada uma das árvores de decisão criadas.

Grande número de árvores: no mundo real, quanto maior uma floresta melhor para nós e no caso das random forests geralmente se trabalha com centenas arvores de decisão, não há um número padrão embora a maior parte dos exemplos encontrados trabalham com 500 árvores por modelo. Cada uma receberá uma amostra aleatória dos dados e fará predições baseadas nestas informações

Seleção aleatória de variáveis: à cada execução de uma árvore um número aleatório de variáveis de sua base de dados é selecionado para ser utilizado. Este número é calculado de acordo com a quantidade total de colunas que forem informadas na criação do modelo.

Resultado baseado na média de acerto de cada árvore: ao final da execução do algoritmo é feita uma média da taxa de acerto de cada uma das centenas de árvores de decisão e das variáveis utilizadas em cada uma, com este resultado as melhores árvores serão utilizadas para os cálculos de predição bem como as variáveis classificadas de acordo com sua utilização taxa de assertividade.

Para ficar mais claro, nada melhor que um exemplo escrito em R :)

pacotes <- c("stringr","tidyr","ggplot2", "plotly", "dplyr", "randomForest", "caTools", "data.table", "kableExtra", "caret", "rpart", "rpart.plot", "funModeling", "janitor")

if(sum(as.numeric(!pacotes %in% installed.packages())) != 0){
  instalador <- pacotes[!pacotes %in% installed.packages()]
  for(i in 1:length(instalador)) {
    install.packages(instalador, dependencies = T)
    break()}
  sapply(pacotes, require, character = T) 
} else {
  sapply(pacotes, require, character = T) 
}

Para este exemplo, utilizarei uma base de dados (disponível no Kaggle) com 11 informações diferentes de 4909 pacientes indicando aqueles que tiveram e não tiveram um ataque do coração.

Para sua utilização foi necessário transformar as variáveis categóricas em fatores e remover a coluna ID, que não será utilizada em nossa análise. Também foram removidas todas as linhas que possuíam alguma informação em branco.

dados = 
  fread("dataset-stroke-data.csv", header = T) %>%
  select(everything(), -id) %>%
  mutate(
    hypertension = as.factor(hypertension),
    heart_disease = as.factor(heart_disease),
    smoking_status = as.factor(smoking_status),
    Residence_type = as.factor(Residence_type),
    work_type = as.factor(work_type),
    ever_married = as.factor(ever_married),
    bmi = as.numeric(ifelse(bmi == "N/A", NA, bmi)),
    stroke = as.factor(ifelse(stroke==0, "N", "Y"))) %>%
  drop_na

summary(dados)

##     gender               age        hypertension heart_disease ever_married
##  Length:4909        Min.   : 0.08   0:4458       0:4666        No :1705    
##  Class :character   1st Qu.:25.00   1: 451       1: 243        Yes:3204    
##  Mode  :character   Median :44.00                                          
##                     Mean   :42.87                                          
##                     3rd Qu.:60.00                                          
##                     Max.   :82.00                                          
##          work_type    Residence_type avg_glucose_level      bmi       
##  children     : 671   Rural:2419     Min.   : 55.12    Min.   :10.30  
##  Govt_job     : 630   Urban:2490     1st Qu.: 77.07    1st Qu.:23.50  
##  Never_worked :  22                  Median : 91.68    Median :28.10  
##  Private      :2811                  Mean   :105.31    Mean   :28.89  
##  Self-employed: 775                  3rd Qu.:113.57    3rd Qu.:33.10  
##                                      Max.   :271.74    Max.   :97.60  
##          smoking_status stroke  
##  formerly smoked: 837   N:4700  
##  never smoked   :1852   Y: 209  
##  smokes         : 737           
##  Unknown        :1483           
##                                 
##

Vamos fazer uma análise exploratória dos dados e verificar se temos alguma informação inconsistente em nossas variáveis categóricas

#Seleção do nome das variáveis categóricas
dados %>% 
  select_if(is.factor) %>% 
  names()

## [1] "hypertension"   "heart_disease"  "ever_married"   "work_type"     
## [5] "Residence_type" "smoking_status" "stroke"

dados %>% tabyl(hypertension) %>% adorn_pct_formatting() %>% arrange(desc(n))
##  hypertension    n percent
##             0 4458   90.8%
##             1  451    9.2%

dados %>% tabyl(heart_disease) %>% adorn_pct_formatting() %>% arrange(desc(n))
##  heart_disease    n percent
##              0 4666   95.0%
##              1  243    5.0%

dados %>% tabyl(ever_married) %>% adorn_pct_formatting() %>% arrange(desc(n))
##  ever_married    n percent
##           Yes 3204   65.3%
##            No 1705   34.7%

dados %>% tabyl(Residence_type) %>% adorn_pct_formatting() %>% arrange(desc(n))
##  Residence_type    n percent
##           Urban 2490   50.7%
##           Rural 2419   49.3%

dados %>% tabyl(smoking_status) %>% adorn_pct_formatting() %>% arrange(desc(n))
##   smoking_status    n percent
##     never smoked 1852   37.7%
##          Unknown 1483   30.2%
##  formerly smoked  837   17.1%
##           smokes  737   15.0%

dados %>% tabyl(stroke) %>% adorn_pct_formatting() %>% arrange(desc(n))
##  stroke    n percent
##       N 4700   95.7%
##       Y  209    4.3%

dados %>% tabyl(work_type) %>% adorn_pct_formatting() %>% arrange(desc(n))
##      work_type    n percent
##        Private 2811   57.3%
##  Self-employed  775   15.8%
##       children  671   13.7%
##       Govt_job  630   12.8%
##   Never_worked   22    0.4%

A variável work_typepossui valores relativamente bem distribuídos, com exceção das pessoas que nunca trabalharam (Never_worked), com apenas 22 registros ou 0.04% de toda a base. Vamos optar pela remoção destes registros para reduzir a quantidade de categorias de nossa base, dado que representam um percentual muito pequeno de dados.

dados = 
  dados %>%
  filter(work_type != "Never_worked")

Uma vez que temos nossa base pronta, seguiremos para a separação de dados para treino de nosso modelo e para testarmos sua acurácia. Mesmo que o algoritmo faça esta verificação interna utilizarei 10% da base para mostrar como ficou resultado.

amostra = sample.split(dados$stroke, SplitRatio = .90, )

treino = subset(dados, amostra == T)
teste  = subset(dados, amostra == F)

A random forest

Embora o modelo faça o cálculo para definir a quantidade variáveis de nossa base que será usada em cada árvore, vamos fazer o cálculo do % de erro que cada combinação gera ao final de uma execução. Para isso vou utilizar o método tuneRF.

mtry = 
  tuneRF(
    #lista das variáveis que serão utilizadas para a especificação do modelo
    treino %>% select(-stroke), 
    # coluna que desejamos prever
    treino$stroke, 
    # quantidade de árvores que devem ser geradas no modelo
    ntreeTry=500,
    stepFactor=1.5,
    improve=0.01)

print(mtry)
##       mtry   OOBError
## 2.OOB    2 0.04297408
## 3.OOB    3 0.04297408
## 4.OOB    4 0.04365621

Algo importante das random foreres e de outros modelos de machine learning é que nem sempre todas as variáveis disponíveis precisam ser utilizadas, neste exemplo poderemos trabalhar com duas variáveis em cada árvore para aumentarmos a chance de um modelo eficaz.

modelo = 
  randomForest(
    # a fórmula da árvore, a informação de ataque cardíaco (stroke) em função de todas as variáveis de nossa base de dados
    formula = stroke ~ .,
    # a base de treino com 4418 registros
    data = treino, 
    # quantidade de colunas que serão utilizadas em cada árvore
    mtry = 2,
    # quantidade de árvores que devem ser criadas pelo algorítmo 
    ntree=500)

Vamos verificar, de acordo com o modelo final quais variáveis foram mais importantes em todas as 500 combinações realizadas:

varImpPlot(modelo, sort = T)

As variáveis avg_glucose_level(média dos níveis de açúcar no sangue), age(idade) e bmi(índice de massa corporal) foram as variáveis mais relevantes enquanto a ever_married (se foi casado alguma vez a menos relevante).

Com o modelo criado podemos realizar a predição de resultado com base nos valores da base de teste e comparar o resultado predito com os valores reais.

pred = predict(modelo, teste, type = "class")

Para verificar o resultado utilizaremos uma matriz de confusão, que faz a comparação entre o real e o predito

confusionMatrix(pred, teste$stroke)

## Confusion Matrix and Statistics
## 
##           Reference
## Prediction   N   Y
##          N 468  21
##          Y   0   0
##                                           
##                Accuracy : 0.9571          
##                  95% CI : (0.9351, 0.9732)
##     No Information Rate : 0.9571          
##     P-Value [Acc > NIR] : 0.5577          
##                                           
##                   Kappa : 0               
##                                           
##  Mcnemar's Test P-Value : 1.275e-05       
##                                           
##             Sensitivity : 1.0000          
##             Specificity : 0.0000          
##          Pos Pred Value : 0.9571          
##          Neg Pred Value :    NaN          
##              Prevalence : 0.9571          
##          Detection Rate : 0.9571          
##    Detection Prevalence : 1.0000          
##       Balanced Accuracy : 0.5000          
##                                           
##        'Positive' Class : N               
##

Este exemplo possui uma acurácia de 95,7%, nada mal! Mas nossa matriz de confusão não traz bons resultados!

Como podemos observar na imagem abaixo, vemos que na linha N e coluna N (valores preditos e reais, respectivamente) que indica pacientes que não tiveram um ataque cardíaco o modelo foi capaz de acertar os 468 registros, ou seja 100% dos casos.

Por outro lado, temos 21 pacientes que tiveram um ataque do coração e o modelo indicou outro resultado, por isso na coluna Y e linha Y da tabela vemos um número 0, mostrando que o modelo errou feio!

##           Reference
## Prediction   N   Y
##          N 468  21
##          Y   0   0

Para resolver este problema é temos alguns caminhos:

1. rever a parametrização do algoritmo, existe um universo de opções que não foram exploradas neste texto e que podem aumentar sua acurácia
2. Aumentar a quantidade dados de treino para que o modelo possa aprender melhor com os dados históricos
3. Avaliar a substituição de variáveis, como o caso da ever_married ou inclusão de novas informações que possam ajudar na previsão de resultados

Por não ser este o objetivo do texto não vamos entrar no detalhe, mas fica a sugestão de contribuição sobre o que pode ser feito para aumentar a acurácia nos casos de em que o modelo falhou e se estiver interessado podemos escrever uma versão 2.0 deste texto :)

Algumas Limitações

Como você viu as random forestes não são a bala de prata dos modelos preditivos e por isso é preciso considera alguns pontos de atenção ao utilizá-las:

1. Elas não muito boas em modelos de regressão, onde o resultado esperado é um valor numérico como o valor de uma ação ou o preço da gasolina
2. Elas podem ser tendenciosas especialmente em casos em que variáveis categóricas possuem muitos valores (categorias), por exemplo, um campo de tipo de cliente que possua 10 ou mais opções, o tipo que possuir mais registros em sua base pode contaminar a predição dos demais.

Mesmo com estes pontos ainda sim as random forests representam um avanço nas técnicas de machine learning e uma ferramenta incrível para a criação de modelos capazes de auxiliar na tomada de decisão.

Se você encontrou algum erro neste texto de conceito ou nos scripts por favor me avise através do e-mail marcosmhs@live.com e terei prazer em fazer a correção e incluí-lo(a) nos créditos.