Tag

R Archives - Análise Macro

Regressões Lineares em R e Python

By | mercado financeiro

É comum em nossas vidas construirmos raciocínios lógicos, a partir de acontecimentos do passado, de que tal variável afetou outra. Muitas vezes, lidamos com diversas teorias que demonstram esses raciocínios de forma cuidadosa de acordo com uma história de acontecimentos e de relações entre as variáveis. Mas, e se tivesse uma forma de conseguir estimar, numericamente o efeito dessas relações? Saber se há significância, ou até mesmo, conseguir a partir do efeito numérico prever um resultado? Tudo isso é possível a partir de uma regressão linear, como mostraremos no post de hoje utilizando o R e  o Python.

Regressão Linear

O objetivo principal da Regressão Linear, é a partir de uma equação matemática, definir o efeito de uma ou mais variável independente em uma variável dependente. O nome linear vem justamente da forma de sua equação, no qual define que esse efeito de relacionamentos é uma função linear dos seus parâmetros. Definimos a equação da seguinte forma:

 Y = a + bx+ erro

Nesta equação definimos uma Regressão Linear Simples, pois há somente uma variável independente x, que afeta a variável dependente Y. Ou seja, através desta equação, definimos o efeito de x em Y. O a é uma constante, que mensura o valor da estimativa caso x seja zero. O b (beta) é o parâmetro (ou coeficiente) que mensura a magnitude de uma variação de x em Y. O erro (também conhecido como resíduo) é simplesmente a diferente entre o valor observado de y com o valor estimado pela equação construída de Y, contendo basicamente as variáveis omitidas do modelo.

Para que não  possamos incorrer de muitos erros na Regressão, de forma contenha muitas variáveis omitidas e o valor predito não seja cheio de erros, podemos aumentar o número de variáveis independente de forma que diminua o valor do erro. Sendo assim, construímos uma Regressão Linear Múltipla, denotada pela equação, um pouco mais formal da seguinte forma:

 y = \beta_0 + \beta_1x_1 + \beta_2x_2 + \dots + \beta_k x_k + \varepsilon

Para estimar o valor de  \beta , o método mais comum é através do Mínimo Quadrados Ordinários, que através do conjunto de dados, minimiza o erro, através soma dos quadrados das diferenças entre o valor estimado e os dados observados. Esse tipo de método é mais comum, devido ao fato de que seus pressuposto são menos rígidos. A equação para Beta segue como:

 \hat{\beta} =arg min_{\beta}\sum_{i = 1}^n (y_i - {\beta} x_i)^2

Feito todas as considerações iniciais, podemos partir para um exemplo real no R e Python para exemplificar melhor o conceito de Regressão.

Regressão Linear no R

Criar uma Regressão Linear no R é algo extremamente simples. O que precisamos ter em mãos são os dados da variável dependente e da(s) variável(is) independente(s) e utilizar a função lm() com a fórmula da Regressão como argumento.

Regressão Linear no R: modelo simples de precificação de ativos

Um exemplo para mostrar o efeito de x sobre y ocorre no contexto de finanças, no qual podemos estimar o retorno de um ativo com base no retorno do mercado. Este é um modelo básico que se utiliza a Regressão Linear Simples e é útil para aqueles que queiram entender melhor sobre o efeito prático das relações entre duas variáveis.

Não iremos discorrer muito sobre a importação e transformação de dados. Essa parte ensinamos por completo no nosso curso de R para o Mercado Financeiro.

Importamos os preços de um ativo no R, bem como os pontos do Ibovespa no mesmo período. Transformamos ambos em forma de retorno diário (isto é, a variação do preço de um dia para o outro). O que queremos saber: o quanto a variação do retorno do Ibovespa, tido aqui como o Retorno do Mercado, afeta o Retorno do Ativo?

Após obter nossos dados, podemos utilizar a função lm() para calcular a regressão. Veja que usamos o simbolo ~, significando que o lado esquerdo (PETR4) é em função da direita (^BVSP). Com a função summary(), sumarizamos os resultados da regressão, obtendo os coeficientes, a significância e o R².

A grosso modo, a leitura dos resultados fica como: A estimativa da constante (intercepto) é igual a 0.001769, a estimativa do coeficiente beta dos retornos da Ibovespa é igual a 1.467227. O intercepto possui um p-valor de 0.16, ou seja, não é significante. Já o coeficiente dos retornos do Ibovespa possui um valor de 2e-16, ou seja, é significante. Medido pelo R², a variabilidade do Ibovespa explica 49,13% da PETR4. Por óbvio, não devemos tirar nenhuma relação de causalidade aqui, apenas de relacionamento entre as variáveis.

Um ponto interessante da Regressão Linear é também poder visualizar a relação de duas variáveis. Utilizando um gráfico de dispersão, é possível ver o relacionamento entre as observações das variáveis, também é possível criar uma Reta de Regressão, na qual realiza o ajuste entre a dispersão dos dados.

No R, criamos um gráfico de dispersão com reta de regressão através do pacote {ggplot2}.

Regressão Linear no Python

No Python, seguiremos o processo igual, retirando os mesmo dados da internet e transformando-os em retornos. Para criar a regressão, utilizaremos a função ols() da biblioteca statsmodels e de sey API formula.api.

No código abaixo seguiremos passos iguais que fizemos no R, importando os preços dos ativos e calculando os retornos diários, além de outros tratamentos.

Por fim, criamos a regressão utilizando a smf.ols com a respectiva formula como argumento. Visualizamos os resultados com fit() e summary(). Apesar de ligeiramente diferente do output do R, os principais resultados estão contidos. Há também uma ligeira diferença dos resultado também, devido ao arredondamento dos dados, porém, bem próximos.

Também é possível criar facilmente um gráfico de dispersão com um Reta de Regressão no Python, para isso, utilizamos a biblioteca {seaborn}.

Quer saber mais sobre R e Python?

Veja nossos cursos de aplicados de R e Python para Economistas. Também oferecemos cursos aplicado ao mercado financeiro através do nosso cursos R para o Mercado Financeiro

Migrando do Excel para R e Python

By | Hackeando o R, Python

Todos sabemos que boa parte do armazenamento e do uso dados viveu (ou ainda vive) dentro de planilhas eletrônicas, principalmente pelo Excel. Não podemos deixar de negar todos os pontos benéficos do uso dessas planilhas, seja pela simplicidade ou pela facilidade de aprender a utilizar uma. Por outro lado, sabemos das dificuldades que o  uso do Excel podem impor, comparado com as linguagens de programação R e Python, principalmente para a área de limpeza de dados, análise exploratória de grandes bases de dados e modelagem. Neste post, iremos mostrar aos usuários do Excel pontos em comuns com R e Python e também o que se pode alcançar a mais com essas linguagens.

Excel e Análise de dados

O Excel, por historicamente estar relacionado com o uso de dados, consequentemente leva aos seus usuários como intuitivamente a utilizar e compreender como trabalhar com dados: é possível ordenar, filtrar, agrupar, juntar dados, calcular suas medidas estatísticas e criar gráficos. Este é um conhecimento útil para análise de dados, porém, haverá momentos em que o usuário ficará preso em pouca variedade de técnicas, além de que se for realizar um passo adiante nessas técnicas irá encontrar dificuldades (no qual será o ponto que R e Python irão preencher).

Para começar nossas comparações e estudos, iremos pegar como exemplo um dataset (um conjunto de dados) com suas colunas (variáveis) e observações (linhas). Cada observação de uma coluna é indexada a outra observação de outra coluna. Importante dizer que uma coluna deve ser homogênea, isto é, possuir o mesmo tipo de dado. A grosso modo, existem dois tipos: categórico e quantitativo (que se dividem em mais tipos).

Veja um exemplo de dataset no Excel:

A partir das variáveis que encontram no dataset, o usuários do Excel poderiam ter uma variedade de recursos e funções para analisá-lo: medidas de tendência central (média, moda, mediana), medidas de dispersão (variância e desvio padrão), ordenamento e agrupamento de categoria, entre outras diversas possibilidades.

R para Análise de dados e Tidyverse

No R, começamos na forma em que podemos manipular os dados, por mais que estejamos lidando aqui com um dataset que está estruturado, é útil para que possamos realizar cálculos e tirar variáveis/observações que não é de nosso interesse. Para isso, iremos apresentar o mundo do Tidyverse, que envolve uma família de pacotes do R, utilizado para manipular dados. As funções mais comuns do Tidyverse são:

  • select() - seleciona as colunas de interesse;
  • mutate() - cria novas colunas baseado nas colunas já existentes;
  • rename() - renomeia as colunas de interesse;
  • arrange() - ordena as colunas de formas crescente ou decrescente;
  • filter() - seleciona as linhas com base em uma condição;
  • group_by() - agrupa as linhas (normalmente dados categóricos) das colunas de interesse;
  • summarize() - agrega os valores de cada grupo (útil para realizar cálculos agrupados);
  • left_join() - junta dois datasets que possuem uma mesma coluna correspondente.

Com o dataset (que no R e Python chamaremos de DataFrame) iris (que vem em conjunto do pacote Tidyverse no R), podemos fazer alguns exemplos, utilizando o Tidyverse para manipulação de dados. O primeiro passo será carregar o pacote (caso não tenha, instale com install.packages('tidyverse')). A função head() permite que possamos dar uma olhada nos dados antes de começar. Entendido os dados, podemos selecionar as colunas de interesse, com a função select(), veja que no primeiro argumento deve ser inserido o DataFrame que queremos utilizar e no segundo argumento a coluna deste DataFrameAlém de selecionar pelo nome, podemos selecionar pelo número da ordem da coluna no DataFrame. No exemplo, selecionamos as colunas de 1 até 3, utilizando 1:3.

Para  realizar o caminho contrário, isto é, retirar colunas de um DataFrame, utilizamos a mesma função, porém, com o símbolo de negação ! do R, que a grosso modo, significa realizar o contrário.

 

 

Para realizar mudanças nas colunas, utilizamos a função mutate(), seguindo o mesmo processo da função anterior, utilizando como primeiro argumento o DataFrame que queremos, por outro lado, como queremos criar uma nova coluna, devemos mudar um pouco a sintaxe, criando um nome para a nova coluna e mudando os valores que queremos com uma função ou cálculo. No exemplo, utilizamos toupper() para que todos as letras da colunas Species sejam maiúsculas.

Para renomear a coluna, utilizamos rename(), orientando o novo nome ao nome atual da coluna. Mudado de Sepal.Length para sepal_length.

A função arrange() irá permitir que a coluna Species fique em ordem crescente. Essa função também reconhece variáveis quantitativas, ordenando números por ordem crescente ou descrecente.

O filter(), como dito, permite filtrar as linhas de acordo com critérios escolhidos. No primeiro uso, colocamos como condição que apenas as observações do DataFrame que possuem Sepal.Width maior que 3.6 apareçam. No segundo uso, colocamos como condição que apenas as Species de nome setosa estivessem no DataFrame. E por último, mostramos como podemos colocar mais de uma condição misturando as duas condições anteriores utilizando o &.

Para agrupar os dados, utilizamos a função group_by, porém, não é tão útil utiliza-la sozinha, visto que precisamos realizar uma chamada de um cálculo ou mudanças nas observações para que tenha efeito. Para isso, o summarize() é uma ótima combinação, permitindo que seja feito operações nas colunas de acordo com o grupo selecionado pelo group_by(). No exemplo, calculamos a média de Sepal.Width para cada Species. Veja também que utilizamos o símbolo %>%, uma função do Tidyverse que nos ajuda a utilizar mais de uma função em sequencia.

Por fim, podemos juntar DataFrames diferentes (ou iguais no caso) para que possamos manipula-los em conjunto. O segredo é que ambos os DataFrames devem possuem pelo menos uma coluna em comum, de forma que elas tenham uma relação entre si. No exemplo, utilizamos a função left_join  para juntar o DataFrame iris da esquerda com o da direito, de acordo com a coluna Species.

Python para Análise de dados e pandas

O Python, assim como o R como Tidyverse, também possui uma biblioteca extremamente importante para facilitar a análise de dados, que é o pandas,  uma biblioteca que oferece um ferramental gigantesco não só para criar e utilizar DataFrames, como também para manipula-los. Nos exemplos, também iremos mostrar os mesmos resultados que obtivemos com o R e o Tidyverse, porém utilizando o pandas do Python.

O primeiro passo será carregar a biblioteca pandas no Python e também o DataFrame iris, que neste caso, utilizamos um arquivo .csv em conjunto com a função do pandas read_csv().

Utilizando a função head(), verificamos o nosso Dataframe para que possamos trabalhar. O primeiro passo será como selecionar colunas no Python, que segue apenas chamando o nosso DataFrame iris e através de dois colchete, selecionarmos os nomes das colunas queremos. Caso utilizarmos apenas um colchete, será retornado um objeto do tipo Series, e não DataFrame, o que não nos é útil no momento.

Para o caminho contrário, usamos drop() para que a coluna de interesse seja excluída do DataFrame. Veja que utilizamos o argumentos axis, isso porque queremos dropar colunas e não linhas.

Para criar novas colunas, seguimos o mesmo raciocínio de colchetes para selecionar colunas, porém utilizamos operadores matemáticos para realizar o procedimento. Veja que no exemplo somamos duas colunas selecionando-as com apenas um colchete (o suficiente para selecionar os valores).

Para ordenar as colunas, utilizamos a função sort_values(), especificando a coluna de interesse com o argumento by. O raciocinio desta função é o mesmo que o do Tidyverse.

Para realizar filtros, o raciocínio segue o mesmo para selecionar colunas, a diferença é que utilizamos o operador lógico para realizar o filtro. O porém aqui é que o que é retornado é na realidade um vetor de True e False dos valores que preencheram a condição exigida. A solução é utilizar o objeto do filtro dentro de um colchete do DataFrame para selecionar as observações do DataFrame.

Em relação ao agrupamento, utilizamos a função groupby() para selecionar a coluna de interesse. Logo em seguinda, utilizamos a função mean() para obter a média de todas as colunas agrupadas por Species.

E por fim, para juntarmos DataFrames, utilizamos a função merge(), que permite juntar DataFrames que possuem colunas em comum. Na função, o argumento on nos permite especificar qual coluna será essa. O argumento how especificar qual coluna será a base.

Vimos neste post as principais funções do R e Python que se assemelham com aquelas utilizadas no Excel para análise de dados. Existe ainda um enorme mundo a ser percorrer em ambas as linguagens, tanto na parte Estatística, de Visualização e também por Modelagem. Aqui na Análise Macro realizamos post diários sobre ambas as linguagens, ensinando desde o básico até o avançado. Para compreender ainda mais ambas as linguagens, nossos Cursos de R e Python aplicados a Ciências de Dados, Economia e Finanças pode lhe ajudar mais ainda.

Quer aprender mais sobre R e Python? 

Abrimos hoje, 22/3, 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!

Séries temporais: detectando mudança de média no R

By | Data Science

Ao analisar séries temporais pode ser útil identificar pontos de mudança em seu comportamento, utilizando métodos de detecção para tal. Existem diversos métodos e algoritmos para implementar esse tipo de análise, desde simples cálculos envolvendo erro quadrático médio até abordagens Bayesianas. Neste texto mostramos uma maneira simples de detectar pontos de mudança em uma série temporal com o método de Taylor (2000).

Metodologia

O método desenvolvido por Taylor (2000), conforme mencionado, se baseia em um cálculo simples de erro quadrático médio (EQM) para identificar quando uma mudança na série ocorreu. A ideia geral é separar a série temporal em segmentos e calcular o EQM dos mesmos para identificar pontos de mudança, considerando o valor que minimiza o EQM. Formalmente:

onde:

Exemplo no R

A implementação do método de detecção de pontos de mudança de média, desenvolvido por Taylor (2000), é feita recursivamente pelo pacote ChangePointTaylor no R.

Neste exemplo aplicamos o método para a série anual da Produtividade total dos fatores da economia brasileira, variável disponível no dataset da Penn World Table 10.0.


# Pacotes -----------------------------------------------------------------

library(ChangePointTaylor)
library(pwt10)
library(dplyr)
library(tidyr)
library(ggplot2)
library(scales)
library(ggtext)

# Dados -------------------------------------------------------------------

# Tibble com dados da Produtividade total dos fatores - Brasil (2017 = 1)
tfp_br <- pwt10::pwt10.0 %>%
dplyr::filter(isocode == "BRA") %>%
dplyr::select(.data$year, .data$rtfpna) %>%
tidyr::drop_na() %>%
dplyr::as_tibble()

tfp_br

# Aplicar método de detecção de mudança (Taylor, 2000) --------------------

# Informar vetor de valores da série e
# vetor de nomes (usalmente a data correspondente ao valor)
change_points <- ChangePointTaylor::change_point_analyzer(
x = tfp_br$rtfpna,
labels = tfp_br$year
)

dplyr::as_tibble(change_points)

# Visualização de resultados ----------------------------------------------

# Gera gráfico ggplot2
tfp_br %>%
ggplot2::ggplot(ggplot2::aes(x = year, y = rtfpna)) +
ggplot2::geom_line(size = 2, color = "#282f6b") +
ggplot2::geom_vline(
xintercept = change_points$label,
color = "#b22200",
linetype = "dashed",
size = 1
) +
ggplot2::scale_x_continuous(breaks = scales::extended_breaks(n = 20)) +
ggplot2::scale_y_continuous(labels = scales::label_number(decimal.mark = ",", accuracy = 0.1)) +
ggplot2::labs(
title = "Produtividade Total dos Fatores - Brasil",
subtitle = "Preços nacionais constantes (2017 = 1)<br>Linhas tracejadas indicam pontos de mudança de média (Taylor, 2000)",
y = "PTF",
x = NULL,
caption = "**Dados**: Penn World Table 10.0 | **Elaboração**: analisemacro.com.br"
) +
ggplot2::theme_light() +
ggplot2::theme(
panel.grid = ggplot2::element_blank(),
axis.text = ggtext::element_markdown(size = 12, face = "bold"),
axis.title = ggtext::element_markdown(size = 12, face = "bold"),
plot.subtitle = ggtext::element_markdown(size = 16, hjust = 0),
plot.title = ggtext::element_markdown(
size = 30,
face = "bold",
colour = "#282f6b",
hjust = 0,
),
plot.caption = ggtext::element_textbox_simple(
size = 12,
colour = "grey20",
margin = ggplot2::margin(10, 5.5, 10, 5.5)
)
)

Referências

Taylor, W. A. (2000). Change-point analysis: a powerful new tool for detecting changes.

 

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!

________________________
(*) Para entender mais sobre a linguagem R e suas ferramentas, confira nosso Curso de Introdução ao R para análise de dados.

Como padronizar gráficos sem repetir código

By | Data Science

Criar gráficos padronizados usando pipelines com o tidyverse no R não precisa ser uma tarefa tediosa de Ctrl+C / Ctrl+V mudando a variável de interesse a ser plotada no seu código de ggplot2. Isso torna o seu script caótico e ineficiente, além de ser potencialmente mais trabalhoso fazer atualização/manutenção desse código.

Uma maneira mais elegante de criar gráficos padronizados, para um relatório por exemplo, pode ser através da escrita de uma função que generaliza o resultado que se quer alcançar. Vamos supor que você queira gerar gráficos de linha padronizados em um relatório extenso. Cada uma das várias visualizações de dados do seu relatório terá um gráfico de linha do ggplot2 para as n variáveis do seu conjunto de dados. Nesta situação, a criação de uma função se encaixa perfeitamente, pois irá unificar em um único comando tudo o que você precisa fazer para todas as visualizações a serem geradas, sem precisar repetir código.

Em termos mais práticos, um exemplo desta situação pode ser código abaixo, onde demonstramos um exemplo bom (usando boas práticas de programação em R) e um exemplo ruim (repetindo manualmente o código).

 

A diferença é bastante clara e significativa, o que você acha melhor? Ambas opções produzem os mesmos resultados gráficos:

O "pulo do gato" aqui, no caso da criação da função plot_line, é utilizar o operador chamado curly-curly para passar os nomes das colunas do objeto data frame diretamente nos argumentos da função que criamos, usando a sintaxe {{ func_arg }} no corpo da função (neste caso em aes). O trabalho "sujo" de identificar corretamente o nome de coluna passado no argumento da função é feito todo internamente por esse operador.

Esse operador se originou em 2019 no pacote rlang e é bastante utilizado internamente nas funções do tidyverse. Se você quiser entender mais a fundo seu funcionamento sugiro começar por este post do blog do tidyverse.

Se mesmo após este exemplo básico você não se convenceu, dê uma olhada na diferença de performance (execução em milissegundos) dos dois códigos após 1000 execuções:

As inovações do tidyverse são maravilhosas e facilitam o dia a dia do usuário de R. Espero que este tenha sido um exercício que instigue curiosidade em investigar se seus códigos performam bem e seguem boas práticas.

 

________________________
(*) Para entender mais sobre a linguagem R e suas ferramentas, confira nosso Curso de Introdução ao R para análise de dados.

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

Assinar Gratuitamente