A corrida da inflação

By | Data Science

Em um post passado eu mostrei que a inflação brasileira comparada a alguns países selecionados está acima da média, com os dados mais recentes. Neste post vou explorar mais o tema com uma perspectiva mais ampla, dialogando com o post recente do professor Roberto Ellery, e aproveitar para exemplificar como podemos gerar uma visualização de dados "animada" no R.

O objetivo é criar uma visualização de dados comparativa entre países selecionados do G20 ao longo dos últimos 10 anos, tomando como base a inflação acumulada em 12 meses. Para tal, usaremos o dataset do IMF e os pacotes ggplot2 e gganimate para gerar a visualização animada.

Uma prévia do resultado final:

Pacotes

Para reproduzir os códigos desse exercício, certifique-se de que tenha os seguintes pacotes instalados/carregados:

Dados

O IMF oferece um rico banco de dados cross-country, sendo que para esse exercício usamos apenas o dataset "CPI", que traz os dados de inflação. Pegamos os dados de inflação % a.m. de 13 países do G20 desde 2011 em frequência mensal e depois acumulamos em 12 meses.

Visualização de dados

Como pode ser observado, os dados estão em formato long, ideal para gerarmos a visualização. Dessa forma, primeiro criamos um objeto auxiliar para armazenar a média histórica da inflação brasileira. Este valor será pontuado no gráfico como uma linha vertical tracejada. Em seguida construímos as camadas do gráfico: com exceção da camada de colunas, o diferencial do gráfico é agregar vários elementos textuais para enriquecer a visualização. Após as definições estéticas e personalizações do tema, usamos a função transition_states() para transformar o gráfico estático do ggplot2 em um gráfico animado (GIF), onde cada frame se refere às observações de 1 ano do conjunto de dados.

Simples, não?

Referências

Recomenda-se consultar a documentação dos pacotes utilizados para entendimento aprofundado sobre as funcionalidades.

- Documentação do ggplot2: https://ggplot2.tidyverse.org/
- Documentação do gganimate: https://gganimate.com/
- Pacote imfr: https://github.com/christophergandrud/imfr

Hackeando o R: Análise de variáveis latentes

By | Hackeando o R

No Hackeando o R de hoje, vamos fazer uma expansão sobre o conteúdo do nosso post de semana passada, sobre análise de fatores. Dentro do contexto de fatores, a classificação com um único fator é equivalente ao clustering, e, considerando que as observações dentro de um mesmo cluster não são correlacionadas, entramos em um modelo chamado de análise de perfil latente. No post de hoje, consideraremos o caso em que as variáveis conhecidas são categóricas, chamado de análise de classes latentes. A ideia é podermos classificar indivíduos em grupos mutuamente exclusivos, a partir de suas respostas a perguntas categóricas. Nesse sentido, podemos ver que esse modelo é útil para a análise de dados de censos, como veremos no exemplo a seguir.

Para apresentarmos o modelo na prática, utilizaremos a base de dados do censo de instituições de saúde mental N-HMSS, disponível aqui. O modelo em si está disponível no pacote poLCA, logo iremos carregá-lo em conjunto com os dados abaixo:

library(poLCA)

seed = 1

data = read.csv('nmhss-puf-2019.csv')

No exemplo, vamos nos limitar aos tratamentos que estão disponíveis em cada instituição, identificados nas colunas 17 a 30. Além disso, precisamos fazer duas mudanças nos dados: números negativos querem dizer NA, e variáveis binárias precisam ser modificadas de 0 e 1 para 1 e 2 - uma limitação do pacote poLCA.

tratamento = data[, names(data)[17:30]]
tratamento[tratamento < 0] <- NA

tratamento <- tratamento + 1

summary(tratamento)

 

Para começar a análise, vamos procurar classes se baseando na oferta de 5 tratamentos: psicoterapia individual (TREATPSYCHOTHRPY), terapia familiar/de casal (TREATFAMTHRPY), terapia em grupo (TREATGRPTHRPY), terapia cognitivo-comportamental (TREATCOGTHRPY) e medicação psicotrópica (TREATPSYCHOMED).

A função poLCA requer 3 inputs: uma fórmula, um dataframe, e o número de classes a procurar. Abaixo, rodamos ela com 2 classes. O resultado é reportado automaticamente. Como podemos ver, para a primeira variável, temos que a probabilidade da segunda classe ser 2 é de 99.27%, ou seja, uma alta probabilidade de que há o tratamento, enquanto que a primeira classe apresenta apenas 33.72% de probabilidade de fornecer ele. Para todas as variáveis temos uma probabilidade maior para a classe 1 do que para a classe 2, indicando que a segunda classe abrange clínicas com maior variedade de tratamentos. Ademais, temos que é estimado que 88.33% das clínicas pertencem à segunda classe.

m <- poLCA(cbind(TREATPSYCHOTHRPY, TREATFAMTHRPY,
TREATGRPTHRPY, TREATCOGTHRPY,
TREATPSYCHOMED) ~ 1,
data = tratamento, nclass = 2)

Podemos visualizar o resultado de modo mais intuitivo com a função plot():


plot(m)

Para finalizar, fazemos algumas adições ao modelo para mostrar outros pontos importantes. Abaixo, trabalhamos com 3 classes, e, para garantir a convergência da estimação (algo que nem sempre ocorre com a função), aumentamos o número de iterações de 1000 para 2500, e rodamos ele 5 vezes. Ademais, mudamos a fórmula para incluir a variável assistência ao pagamento (PAYASST), de modo a identificar como as classes que encontramos se relacionam com ela.


tratamento$PAYASST <- data$PAYASST
tratamento$PAYASST[tratamento$PAYASST < 0] <- NA

m <- poLCA(cbind(TREATPSYCHOTHRPY, TREATFAMTHRPY,
TREATGRPTHRPY, TREATCOGTHRPY,
TREATPSYCHOMED) ~ PAYASST,
data = tratamento, nclass = 3,
maxiter = 2500, nrep = 5)

Como vemos no resultado, temos 3 classes com características distintas: a classe 1 (cerca de 12% da população) tem diversos tratamentos, exceto terapia familiar; a 2 e a 3 (79 e 9% da população, respectivamente), incluem todos os tratamentos, exceto pelo fato de que a 2 tem probabilidade muito menor de incluir medicação. Ademais, podemos verificar a relação que cada classe tem com a assistência ao pagamento: em comparação com a classe 1, clínicas da classe 2 tendem a oferecer menos assistência, enquanto clínicas da classe 3 tendem a oferecer mais.

Exportando data frames do R para planilhas

By | Hackeando o R

Imagine-se na seguinte situação: o seu chefe lhe pede uma análise de um conjunto de dados "sujos", que requerem um enorme trabalho de limpeza, além de que se faça cálculos complexos. Você, inteligente e inovador, pretende realizar todo o trabalho com o R, já que a linguagem permite que você faça o trabalho rapidamente. Há um porém, o seu chefe ainda não conhece muito bem a linguagem, e também necessita passar as informações para outros setores da empresa, e por isso, pede que o conjunto de dados seja entregue em uma planilha. Neste texto, iremos mostrar como é possível resolver esse problema, exportando data frames para planilhas utilizando os pacote {XLConnect} e {googlesheets4}.

# Carrega os pacotes necessários
library(googlesheets4)
library(XLConnect)
library(tidyverse)

Primeiro, iremos mostrar como exportar uma data frame para um arquivo .xlsx. O primeiro passo é carregar o arquivo
de formato .xlsx, para que seja feita a conexão com o R. Veja que é possível conectar a uma planilha já existente, utilizando a função loadWorkbook(), passando nome do arquivo em questão no primeiro argumento, bem como criar um arquivo direto do R, passando o argumento create = TRUE. Fazemos isso tudo salvando em um objeto.

Logo em seguida, realizamos a criação de páginas dentro da planilha, no qual iremos colocar nossos dados. Podemos fazer isso com a função createSheet(), em que passamos o objeto que conecta com o arquivo .xlsx, e o nome da página. Após isso, utilizamos a função writeWorksheet() para enfim escrever os dados na planilha. Veja que podemos escolher as coordenadas em que os dados estarão guardados usando os argumentos startRow e startCol, que por padrão começam na linha 1, coluna 1.

Por fim, salvamos o arquivo utilizando a função saveWorkbook().


# Cria um arquivo .xlsx
flowers <- loadWorkbook("iris.xlsx", create = TRUE)

# Cria uma página no arquivo
createSheet(flowers, "iris1")

# Escreve na página criada
writeWorksheet(flowers, iris, sheet = "iris1", startRow = 1, startCol = 1)

# Salva o arquivo
saveWorkbook(flowers)

Outro pacote muito útil para transformar data frames em planilhas é o {googlesheets4], que justamente conecta os dados em uma planilha no Google Planilhas.

Para isso, é necessário que o pacote tenha permissão da sua conta Google para realizar as mudanças. Para isso, utiliza-se a função gs4_auth(), colocando seu e-mail de uso.

Em seguida, cria-se a planilha utilizando a função gs4_create(), passando o nome da planilha como primeiro argumento, e o data frame que podem ser utilizados.

Em caso de alterações, podemos escrever por cima da planilha utilizando a função write_sheet(). O argumento ss é usado para conectar a planilha, podemos usar tanto a url, quanto o id salvo dentro do argumento iris_gg.

## Google Sheets

# Conecta a conta do Google, para garantir a permissão
gs4_auth(email = "luiz@exemplo.com")

# Cria uma planilha dentro do Google Planilhas
iris_gg <- gs4_create("flowers", sheets = iris)

# Escreve por cima do arquivo criado anteriormente
write_sheet(data = filter(iris, Species == "setosa"),
            ss = "1V2722XxqQHbi_9V_bi5LAxwEHrQTXHCW4OnpyjjxiQg",
            sheet = "iris")

Serve como um bom quebra-galho, não?

Relatório #20 - PMS e IBC-Br

By | Indicadores

No final dessa semana, são anunciados os valores da PMS e do IBC-Br referentes ao mês de agosto, completando as principais pesquisas sobre o nível de atividade da economia. A PMS é particularmente importante pois o setor de serviços teve alta variância durante a pandemia, e há grande expectativa sobre a manutenção de sua recuperação. Como podermos ver abaixo, após a queda causada pelas restrições do começo desse ano, houve uma trajetória de crescimento, porém ela já está diminuindo, indicando que estamos convergindo para um nível estável de comércio.

Podemos ver que, em comparação com as outras pesquisas, a PMS apresenta uma variação anual menor, indicando que a recuperação está atrasada para o setor de serviços. É importante notar, porém, que esse setor ficou abaixo dos valores anteriores por um período prolongado, o que explica seu vale mais profundo no começo de 2021.

Mudando o foco agora para o IBC-Br, que sai nessa sexta-feira, podemos ver no gráfico abaixo que a oferta da economia como um agregado já parece estar recuperada. Observando seu valor em nível, tanto os valores em nível como dessazonalizados aparentam estar levemente abaixo da tendência pré-pandemia, com a variação anual indicando que os impactos do lockdown de 2020 já foram superados pela recuperação que ocorreu na segunda metade do ano.

Por que e como criar environments locais no R?

By | Data Science

Joãozinho é um usuário ativo de R que trabalha simultaneamente em múltiplos projetos de trabalho/faculdade. A medida que os projetos avançam Joãozinho começou a encontrar algumas dificuldades: no projeto A ele precisa de algumas versões específicas de pacotes de R, enquanto que no projeto B ele precisa de alguns desses pacotes em versões mais recentes/diferentes por conta de atualizações de sintaxe, caso contrário o seu código para de funcionar. A solução gambiarra que Joãozinho encontrou foi instalar a versão específica dos pacotes que precisa toda vez que abre cada um dos projetos, para assim poder seguir desenvolvendo os códigos.

A solução de Joãozinho é adequada/eficiente? O que será que ele está fazendo de errado? Você está vivenciando algo parecido? Nesse tutorial iremos explorar o básico de criação de environments locais e independentes para cada projeto de R, permitindo que Joãozinho se livre dessas gambiarras e possíveis conflitos entre projetos.

Aviso 1: se você não sabe o que é ou nunca trabalhou com projetos de R (arquivos .Rproj), você deveria ler urgentemente esse texto.

Aviso 2: neste tutorial iremos utilizar o R 4.1.0 e o pacote renv v0.14.0.

O que são environments locais?

O termo "environment local" talvez não seja o mais acurado e descritivo possível, mas entenda como a biblioteca local de um projeto de R ou um gerenciamento de pacotes/dependências, separada da instalação global de pacotes de R que você tem no computador. Isso significa que quando você está trabalhando em um projeto de R usando um environment local, qualquer pacote que for instalado/removido não afetará os pacotes instalados globalmente em seu computador, pois essas alterações são independentes e feitas somente para o projeto de R em questão. Abre-se, então, a possibilidade de ter entre cada projeto versões diferentes de um mesmo pacote. Isso é bastante interessante, não?

Por que usar environments locais?

Situações em que os seus códigos de um projeto de R param de funcionar com o tempo são irritantes para qualquer um, ainda mais se considerarmos o custo de tempo gasto para fazer a manutenção do código. Dessa forma, qualquer organização ou usuário - como o Joãozinho - que use um gerenciamento de dependências adequado diminuirá significativamente o tempo gasto por desenvolvedores, cientistas e analistas de dados, etc. corrigindo códigos quebrados devido a alterações de versões de pacotes.

Em contraste com a comunidade de Python, que parece muito familiarizada com seu gerenciamento de dependências virtualenv ou pipenv, a comunidade de R não parece ter adotado amplamente essa prática. Talvez o viés mais estatístico da comunidade de R explique essa diferença. De qualquer forma, se você usa intensamente o R, você tem muito a ganhar em produtividade com a adoção do gerenciamento de pacotes!

Como funciona?

Apesar da construção de um environment local não ser um procedimento nada trivial se "feito à mão", sua operacionalização na prática é extremamente simples, graças ao pacote renv. As principais vantagens de usar esse pacote, conforme destacado na documentação, são:

  • Isolamento: instalar, remover ou atualizar pacotes não fará com que seus outros projetos de R parem de funcionar, pois para cada projeto é criado um environment (biblioteca) local;
  • Portabilidade: estrutura facilitada para trabalhar com seus projetos de um computador para outro, ou até mesmo em sistemas operacionais diferentes;
  • Reprodutibilidade: graças ao registro exato de cada versão de pacote que o projeto depende, fica fácil abrir o projeto em outro ambiente e ter a mesma "fotografia" de pacotes utilizados e assim seguir com o trabalho/código normalmente.

A filosofia do pacote é de que o seu projeto de R deve continuar funcionando normalmente, com a vantagem agora de que o renv irá introduzir uma estrutura de gerenciamento de dependências, tornando o projeto mais robusto e reprodutível.

Agora que você já conhece o renv, vamos para a parte prática. Primeiro certifique-se de que tenha o pacote instalado:


# Versão CRAN
install.packages("renv")

# Versão GitHub
if(!requireNamespace("remotes")) install.packages("remotes")
remotes::install_github("rstudio/renv")

O fluxo de trabalho básico ao utilizar o renv em um projeto de R pode ser resumido em 2 funções bem simples:

  1. Execute renv::init() para criar uma estrutura de biblioteca local para o projeto de R ativo. A função detecta os pacotes usados no projeto ativo e registra eles em um arquivo chamado renv.lock . Você pode executar essa função em projetos existentes ou em recém criados.
  2. Trabalhe em seu projeto normalmente, instalando, removendo ou atualizando pacotes de R conforme necessidade. Se você executou o comando anterior em um projeto recém-criado, você precisará instalar pacote por pacote conforme utilizá-los.
  3. Execute renv::snapshot() para salvar o estado atual do seu projeto. Isso fará com que os pacotes instalados/removidos durante a sessão sejam registrados no arquivo renv.lock . Confira as mensagens que aparecem no Console, o pacote proporciona uma experiência bastante "self-service".

E isso é praticamente tudo que você precisa saber de início para operacionalizar um environment local para seu projeto de R! Muito simples, não?

Uma vez que você seguiu esses passos você deve ter algo parecido com essa estrutura de arquivos no seu projeto de R:

Na pasta renv será criada a estrutura de biblioteca local para o seu projeto. O arquivo renv.lock mantém o último registro (renv::snapshot) de todos os pacotes, incluindo versões, utilizados no projeto. Por fim, o arquivo .Rprofile terá uma linha de comando de R para fazer com que seu projeto sempre inicialize o renv ao ser aberto.

Na aba Packages do RStudio também será possível notar visualmente os pacotes da biblioteca local do projeto:

Uma dica importante caso fique com dúvidas em algum momento do fluxo de trabalho usando o renv no projeto é a obtenção do status atual do gerenciamento de dependências com a função renv::status() que reporta a diferença entre os pacotes atualmente usados no projeto com o que está registrado no arquivo renv.lock .

Outra dica: quando você quiser reverter para um estado anterior registrado no renv.lock , devido a problemas trazidos por uma instalação de pacote ou algo do tipo, basta executar renv::restore() .

Por fim, recomendo dar uma olhada na documentação do pacote, para mais informações e detalhes das funcionalidades do renv . Tenho certeza de que uma vez que você começar a utilizá-lo e dar tempo suficiente para se acostumar com ele em seu fluxo de trabalho, jamais irá se arrepender ou criar projetos sem gerenciamento de dependências!

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

Assinar Gratuitamente
{"cart_token":"","hash":"","cart_data":""}