Tag

dashboard no r Archives - Análise Macro

Dashboard de Política Fiscal

By | Indicadores

Acompanhar os resultados fiscais do Brasil devem estar entre os principais pontos de analises feitos por aqueles que desejam acompanhar a conjuntura econômica do país. Investigar os principais resultados fiscais das diferentes esferas do governo, sejam valores nominais ou deflacionados. Para tanto, aqui na Análise Macro, ensinamos nossos alunos não somente a teoria sobre a política fiscal, bem como a construção de um painel de monitoramento para esta área da analise de conjuntura. No post de hoje, mostraremos o Dashboard de Política Fiscal, construído com base no Curso de Análise de Conjuntura com o R.

Nas últimas semanas, realizamos demonstrações sobre os dashboards de nível de atividade econômica e de inflação, produzidos aqui na Análise Macro, no qual também ensinamos nestes posts a como realizar o deploy desses painéis. Demonstramos também nossos Dashboards de Mercado de Trabalho e Política Monetária. Para tanto, mostraremos aqui o Dashboard de Política Fiscal.

Você pode ver o resultado através do seguinte link:https://analisemacro.shinyapps.io/dashboard_fiscal/

Na primeira aba, encontramos a Necessidade de Financiamento do Setor Público para diferentes esfera do governo e em diversas unidades de medidas. Dentre as possibilidades de input do NFSP por esfera de governo, temos:  INSS, Governo Federal, Governo Estadual, Governos Municipais, Empresas Estatais e Setor Público Consolidado. Para as unidades de medida, encontra-se disponíveis: Valores Nominais, Valores Deflacionados, Valores Nominais (12 meses, % do PIB) e Valores Deflacionados (12 meses).

Como possibilidade input, também encontra-se o filtro de período de seleção. Os gráficos dispostos sugerem os diferentes indicadores da NFSP, bem como há uma tabela demonstrando os valores deflacionados em meses para diferentes esferas de governo.

Na segunda aba, encontra-se disponível as diversas contas desagregados do Resultado Primário do governo, em diferente unidades de medidas, sendo estas as mesmas da primeira aba, adicionado a Variação Percentual (12 meses, %).  O interessante desta aba é que é possível baixar as contas (em formato long), em uma planilha .csv.

Na terceira aba, há as contas desagregadas da Dívida Pública, com os gráficos das diferentes métricas de Endividamento Público. Nas Unidades de Medida, encontra-se três possíveis valores: Valores Nominais, Valores Deflacionados e Valores Nominais (% do PIB).

Quer aprender a criar Dashboards com o R?

Nos cursos oferecidos pela Análise Macro, você consegue criar as habilidades necessárias para criar Dashboards com o R utilizando os principais indicadores Econômicos e Financeiros. Veja nossos cursos de Análise de Conjuntura usando o R, Produção de Dashboards, Modelos Preditivos (de Machine Learning) aplicados à Macroeconomia e R para o Mercado Financeiro.

Dashboard de política monetária

By | Indicadores

Investigar os caminhos da política monetária no Brasil é uma tarefa que qualquer analista que trabalhe com economia e/ou finanças não pode deixar de lado, sendo o acompanhamento das taxas de juros, bem como os caminhos das expectativas de mercado para o PIB, Selic, Câmbio e IPCA imprescindíveis para tomar qualquer conclusão sobre o cenário atual e futuro. Para tanto, aqui na Análise Macro, ensinamos nossos alunos não somente a teoria sobre a política monetária, bem como a construção de um painel de monitoramento para esta área da analise de conjuntura. No post de hoje, mostraremos o Dashboard de Política Monetária, construído com base no Curso de Análise de Conjuntura com o R.

Nas últimas semanas, realizamos demonstrações sobre os dashboards de nível de atividade econômica e de inflação, produzidos aqui na Análise Macro, no qual também ensinamos nestes posts a como realizar o deploy desses painéis. Para o dashboard de Política Monetária não é diferente, caso queira realizar o compartilhamento online do painel é possível seguindo os mesmo passos.

Você pode ver o resultado através do seguinte link: https://analisemacro.shinyapps.io/dashboard_monetaria/

Existem três abas no dashboard: Visão Geral, Expectativas de Mercado e ETTJ, cada uma contendo gráfico importantes para o acompanhamento da política monetária no Brasil. A primeira aba, visão geral, evidencia a relação do Juro Real ex-ante com o Juro Neutro ao longo do tempo, demonstrando os momentos que a política monetária deve ser expansionista ou contracionista. Também demonstra, em uma tabela, o acompanhamento das expectativas de mercado, com base no Boletim Focus  semanal para os principais indicadores da economia do ano atual e do próximo ano, sendo os indicadores: IPCA, PIB, Câmbio e Selic.

Na segunda aba, evoluímos as tabela dos indicadores econômicos traçados pela expectativas do Focus para uma gráfico que contém a trajetória ao longo do tempo dos valores da pesquisa de cada indicador do Focus, com um input para cada indicador. Na imagem abaixo, vemos a evolução das Expectativas de mercado para a Selic.

 

Por fim, na terceira aba, visualizamos a Estrutura a Termo de Taxa de Juros, demonstrado os valores no dia para os títulos indexados ao IPCA em diferentes vencimentos.

Quer aprender mais sobre R e Python? 

Abrimos as inscrições com 30% de desconto para as Turmas de Outono dos nossos Cursos Aplicados de R e Python. As vagas com esse desconto são limitadas aos primeiros inscritos. Haverá vagas para 25 Cursos Livres e 3 Formações. As turmas de Outono terão início no dia 04/04 e contarão com Cursos de Introdução à Programação em R ou Python, de modo que não é necessário nenhum conhecimento prévio nas linguagens. Para todos os detalhes sobre as Turmas de Outono, entre neste link e garanta sua vaga!

Dashboard de Mercado de Trabalho

By | Indicadores

O Mercado de trabalho configura em uma associação de relações entre demanda e oferta de trabalho e na análise de conjuntura, investigar esta área é de grande importância, devido a riqueza de informações que os indicadores passam sobre a situação socioeconômica do país. Na Análise Macro, realizamos essa investigação da forma mais facilitada possível: com um dashboard! Com base nos painéis interativos produzidos no nosso Curso de Análise de Conjuntura, conseguimos analisar por completo essa área. No post de hoje mostraremos o dashboard de mercado de trabalho.

Nas últimas semanas, realizamos demonstrações sobre os dashboards de nível de atividade econômica e de inflação, produzidos aqui na Análise Macro, no qual também ensinamos nestes posts a como realizar o deploy desses painéis. Para o dashboard de trabalho não é diferente, caso queira realizar o compartilhamento online do painel é possível seguindo os mesmo passos.

Você pode ver o resultado através do seguinte link: https://analisemacro.shinyapps.io/dashboard_trabalho/

Existem três abas no dashboard, contando com a página inicial. Na primeira, que é a página inicial, demonstra a visão geral do mercado de trabalho, exibindo gráfico temporal da variação da taxa do desemprego medida pela PNADc mensal. As caixas exibem os valores dos ocupados e desocupados em milhões, medidos pelo IBGE, bem como o último valor da taxa de desocupados.

Na segunda aba, demonstra o termômetro do PNADc, desagregando o seus principais indicadores, separando-os também por abas.  Na primeira, é medido em milhões de pessoas a População total (PIA), a Força de Trabalho (PEA), o número de Ocupados e Desocupados, as pessoas Fora da Força de Trabalho (PNEA), a Taxa de Desocupação, o Nível de Ocupação e  a Taxa de Participação.

Em Ocupação por categorias, é desagregado as categorias do tipo de emprego pelas pessoas ocupadas. mostrando em milhões o Empregado com e sem Carteira, o Trabalhador Doméstico, o Empregado do Setor Público, o Trabalhador familiar auxiliar, o Empregador e aqueles que trabalham por Conta Própria.

Também é desagregado em relação aos grupos de atividade exercidos pelo trabalhadores, medidos em milhões de pessoas, demonstrando as áreas de Agricultura, Indústria Geral, Construção, Comércio, Transporte, Alojamento e alimentação, entre outros tipos de atividade, que são medidos pela PNADc.

É também possível acompanhar o rendimento dos trabalhadores, em reais, ao longo do tempo. Vemos no dashboard o rendimento médio real e nominal em uma aba de rendimentos, bem como também é possível ver a massar de rendimentos em milhões em outra aba (também real e nominal).

Por fim, vemos ao longo do tempo o Saldo no Novo CAGED a nível nacional, em milhares.

 

Como foi possível ver, o dashboard de mercado de trabalho nos force informações importantes para analisar a conjuntura e os caminhos econômicos percorridos no país, o útil a sua fácil utilização. Aqui na Análise Macro, ensinamos a construir dashboards iguais a este com nossos Curso de Análise de Conjuntura com o R e de Produção de Dashboards.

 

Dashboard de Inflação: como automatizar com o Github Actions

By | Indicadores

Na última semana, ensinamos como é possível realizar o deploy de um dashboard do nível de atividade econômica brasileira, construído através do Shiny, em uma webpage através do Shiny apps. Através deste método, é necessário que haja um trabalho manual para realizar a atualizações  de dados do dashboard, e de forma que possamos melhorar este processo, ensinaremos neste post como automatizar a atualizações de dados de um painel, utilizando como exemplo o Dashboard de Inflação construído através do nosso Curso de Análise de Conjuntura com o R.

O processo de automatização de scripts no Github envolve alguns passos e conhecimentos necessários, sendo alguns tópicos de certa forma avançados, exigindo algum tempo de estudo. Porém, aqui iremos simplificar o processo para que todos consigam utilizá-lo. O processo aqui envolve utilizar um Dashboard criado no R utilizando o Flexdashboard e Shiny, sendo portanto um dashboard dinâmico. Essa informação é importante, devido ao fato de que caso haja a utilização de outro tipo de dashboard é necessário que ocorra ajustes nos procedimentos.

Dashboard de Inflação

Aqui na Análise Macro ensinamos a criar dashboard para análise de conjuntura brasileira de forma totalmente reprodutível e automática. Você pode checar o resultado através deste link https://analisemacro.shinyapps.io/dashboard_inflacao/.

Dito isto, podemos prosseguir com os passos necessários para a automatização do dashboard.

Pré-requisitos

  • Ter instalado o R e RStudio
  • Ter instalado o Git
  • Criar uma conta no GitHub
  • Criar uma conta no Shiny App
  • Ter em mãos o dashboard construído através do Curso de Análise de Conjuntura

Após todos estes procedimentos, podemos então seguir no envio dos arquivos do dashboard para o Github, de forma que seja criado um repositório no site e que possa realizar o deploy no Shiny App através do Github, e que ele possa realizar a automatização com o Github Actions.

1° passo

Abra o projeto do dashboard (dashboard_inflation.Rproj) em conjunto com o arquivo .Rmd. Primeiro precisamos gerenciar as dependências do dashboard (isto é, o pacotes utilizados no script), de forma que o Github reconheça quais devem ser baixados pelo Github Actions.

Com os arquivos do dashboard aberto, utilize o seguinte código no console.


renv::init()

renv::snapshot()

2° passo

Configurado as dependências, podemos então exportar os arquivos para o repositório do Github. Para criar o repositório, devemos seguir os seguintes passos:

  1. Estar logado no GitHub
  2. Clicar no botão New
  3. Definir um nome do repositório
  4. Clicar em Create repository

Ao criar o repositório, aparecerá alguns comandos em Git, que podemos utilizar para integrar o projeto do nosso dashboard com o repositório. Copiamos o código que aparece na sugestão "…or create a new repository on the command line" e colamos no Terminal do Rstudio. No nosso exemplo utilizamos o seguinte código:


echo "# dashboard_inflacao" >> README.md

git init

git add README.md

git commit -m "first commit"

git branch -M main

git remote add origin https://github.com/analisemacro/dashboard_inflacao.git
git push -u origin main

git add .

git commit -m "add dashboard"

git push

3° passo

Com efeito, integramos nossos arquivos remotos com o Github, o seguinte passo será rodar o dashboard no Github em conjunto com o Shiny Apps, de forma que ele seja atualizado automaticamente com o Github Actions. Mais importante, será configurar o Github em conjunto com o Shiny App. Para isso, devemos coletar os secrets (chaves) do Shiny Apps.
  1. acesse shinyapps.io
  2. entre em sua conta (caso não tenha, crie uma)
  3. clique na imagem do perfil e vá em tokens
  4. na página, utilize o token que deseja para realizar o deploy do dashboard, caso não tenha um token, clique em new token
  5. com o secrets em mãos, deveremos colocá-los no Github. No repositório, acesse Settings > secrets > actions > New repository secret. Em cada novo secret, utilize os nomes utilizados na imagem, e que correspondem para os nomes dos secrets relacionados aos tokens do Shiny App.

Temos o suficiente agora para conseguir utilizar o Github Actions.

4° passo

Neste passo, iremos criar um workflow que possa realizar o deploy no Shiny app e atualizá-lo a cada dia automaticamente.
Para criar um workflow , deve acessar a página ''Actions'' e criar um novo workflow, através de new workflow >  set up a workflow yourself . É possível alterar o nome do arquivo para qualquer um, aqui utilizaremos "update.yml"
Na parte "Edit file", exclua o código padrão e copie o seguinte código para realizar a configuração do deploy do dashboard e manter a atualização diária.
on:
push:
branches:
- main
- master
schedule:
- cron: "0 0 * * *"

name: Dashboard update

jobs:
Dashboard-update:
runs-on: windows-latest
env:
GITHUB_PAT: ${{ secrets.GITHUB_TOKEN }}
RSCONNECT_USER: ${{ secrets.RSCONNECT_USER }}
RSCONNECT_TOKEN: ${{ secrets.RSCONNECT_TOKEN }}
RSCONNECT_SECRET: ${{ secrets.RSCONNECT_SECRET }}
steps:
- uses: actions/checkout@v2
- uses: r-lib/actions/setup-r@v1
with:
r-version: '4.1.2' # The R version to download

- name: Cache packages
uses: actions/cache@v2
with:
path: ~\AppData\Local\renv
key: ${{ runner.os }}-renv-${{ hashFiles('**/renv.lock') }}
restore-keys: |
${{ runner.os }}-renv-
- name: Restore packages
run: |
if (!requireNamespace("renv", quietly = TRUE)) install.packages("renv")
renv::restore()
shell: Rscript {0}

- name: Install workflow dependencies
run: |
install.packages(c("rcmdcheck", "sessioninfo", "devtools"))
shell: Rscript {0}

- name: Install pandoc
run: |
choco install pandoc

- name: Authorize and deploy app
run: |
rsconnect::setAccountInfo(name='${{ secrets.RSCONNECT_USER }}', token='${{ secrets.RSCONNECT_TOKEN }}', secret='${{ secrets.RSCONNECT_SECRET }}')
rsconnect::deployApp(account = 'analisemacro', forceUpdate = TRUE)
shell: Rscript {0}

- name: Commit results
run: |
git config --local user.name "GitHub Actions"
git config --local user.email "actions@github.com"
git add .
git commit -m "Update data and deploy shiny app" || echo "No changes to commit"
git push origin || echo "No changes to commit"

Importante dizer que é necessário que o código deva conter uma indentação específica, para obter um exemplo de como pode realizar através do códigos, veja aqui.

Esta parte é um pouco complexa de se entender, portanto, não iremos nos aprofundar no papel de cada código.

Com isso, finalizamos todos os passos de construção do nosso workflow. Agora, será feito o deploy do nosso dashboard na página do Shiny App, bem como será feito esse procedimento todos os dias automaticamente.

Construindo uma dashboard de ações no R

By | mercado financeiro

O estudo da análise de dados envolve primordialmente transformar dados 'crus' em informação útil, de forma que seja comunicado de forma mais simples possível para que qualquer usuário possa entender. Um meio interessante de transformar esses dados em uma forma simples de visualização é criando uma dashboard. Esse tipo de painel interativo pode ser criado em diferentes áreas de estudos, o que não é diferente para as finanças. No post de hoje, apresentaremos uma dashboard básica para a análise de ações da bolsa de valores criada no R.

A dashboard deverá conter os principais indicadores dos quais o usuário pretende tirar seus insights. Nesta dashboard criada como exemplo, demonstramos o preço da ação, o retorno mensal, o retorno acumulado e o desvio padrão, sendo este um gráfico móvel no qual é possível ter uma estimativa do risco de mercado das ações analisadas. Podemos também colocar inputs dentro dessas dashboard de forma que seja possível ter mais flexibilidade.

Como podem ver na imagem, a barra lateral possui 3 inputs: o nome do ticker da ação (que pode ser encontrado no site do Yahoo Finanças), a data inicial de análise e a janela móvel do desvio padrão (e que funciona somente neste indicador).

Você pode conferir o resultado neste link.

Para criar a dashboard utilizou-se do seguinte YAML:

Com os seguintes pacotes:


library(tidyverse)
library(highcharter)
library(tidyquant)
library(timetk)
library(scales)

A criação da dashboard seguiu como uma junção da Flexdashboard e Shiny, além dos gráficos serem criados através do Highchart.

Sidebar {.sidebar}
=====================================

# Construção dos inputs da barra lateral do dashboard

fluidRow(
column(6,
textInput("stock1", "Stock 1", "VIVT3.SA"))
)


fluidRow(
column(6,
textInput("stock2", "Stock 2", "ITSA4.SA"))
)

fluidRow(
column(6,
textInput("stock3", "Stock 3", "TAEE4.SA"))
)

fluidRow(
column(6,
textInput("stock4", "Stock 4", "BRSR6.SA"))
)

fluidRow(
column(7,
dateInput("date", "Starting Date", "2013-01-01", format = "yyyy-mm-dd"))
)

fluidRow(
column(6,
numericInput("window", "Window", 6, min = 3, max = 20, step = 1))
)

actionButton("go", "Submit")


### Coleta, tratamento e calculos

# Coleta os preços das ações
prices <- eventReactive(input$go, {

symbols <- c(input$stock1, input$stock2, input$stock3, input$stock4)

getSymbols(symbols, src = 'yahoo', from = input$date,
auto.assign = TRUE, warnings = FALSE) %>%
map(~Ad(get(.))) %>%
reduce(merge) %>%
`colnames<-`(symbols)
})

# Transforma os preços xts em mensal

prices_monthly <- eventReactive(input$go, {

prices <- prices()

to.monthly(prices(),
indexAt = "last",
OHLC = FALSE)
})

# Calcula os retornos mensais em xts e wide

asset_returns_xts <- eventReactive(input$go, {

asset_returns_xts <- na.omit(Return.calculate(prices_monthly(),
method = "log"))
})

# Transforma os preços em tibble, mensal e long

prices_monthly_tbl_long <- eventReactive(input$go, {
prices <- prices()

asset_returns_long_tbl<- prices %>%
to.monthly(indexAt = "last",
OHLC = FALSE) %>%
tk_tbl(preserve_index = TRUE,
rename_index = "date") %>%
gather(asset,
prices,
-date)
})

# Calcula os retornos mensais em tibble e long

asset_returns_long_tbl <- eventReactive(input$go, {

prices_monthly_tbl_long <- prices_monthly_tbl_long()

prices_monthly_tbl_long %>%
group_by(asset) %>%
mutate(returns =
(log(prices) - log(lag(prices)))
) %>%
na.omit()
})

# Calcula o retornos acumulado

asset_acum_return_tbl <- eventReactive(input$go, {
asset_returns_long_tbl <- asset_returns_long_tbl()

asset_acum_return_tbl <- asset_returns_long_tbl %>%
group_by(asset) %>%
mutate(acum_return = cumsum(returns))
})

# Calcula o desvio padrão móvel das ações (volatilidade)

rolling_sd_tbl <- eventReactive(input$go, {
rolling_sd_tbl <-
rollapply(asset_returns_xts(),
FUN = sd,
width = input$window) %>%
na.omit() %>%
tk_tbl(preserve_index = TRUE,
rename_index = "date") %>%
gather(asset,
sd,
-date)
})

 

Painel de Acompanhamento
=====================================

Row {data-height=600, .tabset}
-----------------------------------------------------------------------

### Preços

renderHighchart({

hchart(prices_monthly_tbl_long(), type = "line",
hcaes(x = date,
y = prices,
group = asset)) %>%
hc_yAxis(opposite = FALSE) %>%
hc_tooltip(pointFormat = '{point.x: %Y-%m-%d}
R${point.y:.4f}')

})

### Retornos mensais

renderHighchart({

hchart(asset_returns_long_tbl(), type = "column",
hcaes(x = date,
y = returns * 100,
group = asset)) %>%
hc_yAxis(opposite = FALSE,
labels = list(format = "{value}%")) %>%
hc_tooltip(pointFormat = '{point.x: %Y-%m-%d}
{point.y:.4f}% ')

})

### Retornos Acumulados

renderHighchart({

hchart(asset_acum_return_tbl(), type = "line",
hcaes(x = date,
y = acum_return * 100,
group = asset)) %>%
hc_yAxis(opposite = FALSE,
labels = list(format = "{value}%")) %>%
hc_tooltip(pointFormat = '{point.x: %Y-%m-%d}
{point.y:.4f}% ')

})

Row {.tabset .tabset-fade}
-------------------------------------

### Desvio Padrão Móvel

renderHighchart({

hchart(rolling_sd_tbl(), type = "line",
hcaes(x = date,
y = sd * 100,
group = asset)) %>%
hc_yAxis(opposite = FALSE,
labels = list(format = "{value}%")) %>%
hc_tooltip(pointFormat = '{point.x: %Y-%m-%d}
{point.y:.4f}% ')

})

Quer aprender a criar dashboards financeiros? Veja nosso Curso de R para o Mercado Financeiro e Produção de Dashboards.

Receba diretamente em seu e-mail gratuitamente nossas promoções especiais
e conteúdos exclusivos sobre Análise de Dados!

Assinar Gratuitamente