Orientações para Problemas com Anaconda para Windows

Algumas pessoas tem encontrado alguns bugs para fazer a instalação do Anaconda no Windows. São alguns problemas que podem acontecer dependendo da plataforma de hardware e dos softwares instalados. O problema mais comum é depois que a instalação está concluída, simplesmente parece que o Anaconda não foi instalado e os atalhos não são criados. Se este ou outro problema acontecer, sugerimos as seguintes ações (em ordem):

  • Reiniciar o sistema operacional logo depois da instalação. Em geral, os ícones serão gerados após a reinicialização
  • Fazer a instalação do Anaconda usando o usuário administrador (ou com permissões totais de administrador)
  • Criar um novo usuário no Windows e fazer a instalação no Anaconda neste novo usuário (com permissões de administrador)
  • Remover todas as instalações anteriores do Python ou Anaconda (inclusive apagar as pastas manualmente)
  • Tentar instalar uma versão mais antiga do Anaconda – ver aqui: https://repo.continuum.io/archive/

Essas são as soluções que resolvem a maioria dos casos, porém, sugerimos consultar os links abaixo caso ainda tenha problemas

https://www.youtube.com/watch?v=qb2_OeHvyK4


https://stackoverflow.com/questions/46335789/anaconda-navigator-wont-launch-windows-10

 

Caso ainda tenha problemas, sugerimos fazer a instalação padrão do Python e usar a IDE PyCharm:

Analise de Regressão Simples – Exercício de Fixação

Enunciado
A atividade de fixação desta trilha será a resolução de alguns problemas de Análise de Regressão Simples utilizando o R. Problema 1 Para uma amostra de oito operadores de máquina, foram coletados o número de horas de treinamento (x) e o tempo necessário para completar o trabalho (y). Os dados coletados encontram-se na tabela abaixo:

Com estes dados, faça: a) Um gráfico de dispersão para os dados b) Determine o modelo de regressão linear simples entre as variáveis x e y, sendo y a variável resposta. c) Faça uma análise do modelo de regressão utilizando a função summary i: resíduos, significância estatística dos coeficientes, percentual de variância explicada pelo modelo. d) Trace, no gráfico anterior, a reta de regressão.

Resposta 1 – A) Um gráfico de dispersão para os dados x <- c(5.2, 5.1, 4.9, 4.6, 4.7, 4.8, 4.6, 4.9) y <- c(13 , 15 , 16, 20, 19, 17, 21, 16) dados <- data.frame(x = x, y = y) plot(x,y)

Verificamos que se trata de uma correlaçãolinear negativa: observando o gráfico da esquerda para a direita, verifica-se que, conforme a variável “x” aumenta (número de horas de treinamento), a variável “y” (o tempo necessário para completar o trabalho) diminui.
Resposta 1 – b) Determine o modelo de regressão linear simples entre as variáveis x e y, sendo y a variável resposta. mod <- lm(y ~ x, data = dados) mod ## ## Call: ## lm(formula = y ~ x, data = dados) ## ## Coefficients: ## (Intercept) x ## 74.90 -11.91 Aplicamos o comando de Regressão Linear com lm(y~x) Resposta 1 - c) Faça uma análise: Do modelo de regressão utilizando a função summary summary(mod) ## ## Call: ## lm(formula = y ~ x, data = dados) ## ## Residuals: ## Min 1Q Median 3Q Max ## -0.72059 -0.52941 -0.02941 0.27941 0.89706 ## ## Coefficients: ## Estimate Std. Error t value Pr(>|t|)
## (Intercept) 74.897 5.514 13.58 9.88e-06 ***
## x -11.912 1.136 -10.49 4.42e-05 ***
## —
## Signif. codes: 0 ‘***’ 0.001 ‘**’ 0.01 ‘*’ 0.05 ‘.’ 0.1 ‘ ‘ 1
##
## Residual standard error: 0.6624 on 6 degrees of freedom ## Multiple R-squared: 0.9483, Adjusted R-squared: 0.9396
## F-statistic: 110 on 1 and 6 DF, p-value: 4.416e-05

i: resíduos, significância estatística dos coeficientes, percentual de variância explicada pelo modelo.
Observando o p (p-value) e convertendo-o temos: (0,00004416) que é muito menor que os níveis de significância especificados para amostra que geralmente são (0,10;0,05 ou 0,01), a diferença é bem significativa.
Propomos um modelo de regressão linear de primeira ordem dado pela equação: =0+1+² onde 01 são parâmetros desconhecidos ² é o erro aleatório. O R retorna o valor dos coeficientes de ^0 e ^ 1 estimados via Método de Mínimos Quadrados. Logo, a equação da reta ajustada é dada por ^ = -11.91X + 74.90

A função summary apresenta os quartis da distribuição dos resíduos; pelos valores apresentados, os resíduos não indicando distorções na distribuição. Faremos os gráficos diagnósticos do ajuste para melhor análise.

Resposta 1 – d)Trace, no gráfico anterior, a reta de regressão.

par(mfrow = c(2,2))
plot(mod)

Analisando o gráfico dos “Residuals vs Fitted” (resíduos versus ajustado): Este gráfico é um exemplo clássico de um resíduo “bem comportado” . Aqui estão as características de um lote bem-comportado versus o gráfico de ajustes e o que eles sugerem sobre a adequação do modelo de regressão linear simples: a) Os residuais “saltam aleatoriamente” em torno da linha 0. Isso sugere que a suposição de que o relacionamento é linear é razoável. b) Os resíduos formam aproximadamente uma “faixa horizontal” ao redor da linha 0. Isso sugere que as variações dos termos de erro são iguais. c) Nenhum resíduo “destaca-se” do padrão aleatório básico de resíduos. Isso sugere que não há “outliers”. Pelo gráfico Normal Q-Q observamos também que os resíduos têm uma distribuição que se aproxima bem da normal. Estas duas constatações nos permitem dizer que estamos atendendo as hipóteses de homocedasticidade e distribuição normal da variável resposta, requisitos do método dos mínimos quadrados ordinários. Podemos obter o coeficiente de correlação linear (r) por meio do comando:

cor(x,y)

## [1] -0.9737856

Podemos interpretar o sinal negativo como sendo causado pelo decrescimento do valor de y ao longo de x. Por outro lado, se tomarmos o módulo de r (coeficiente linear) teremos uma correlação linear negativa forte, conforme a tabela abaixo:

O trabalho decresce em relação à proporção com que se aumenta o número de horas do treinamento. Ou seja, y decresce quase na mesma velocidade com que x cresce. Por fim, ainda, podemos calcular e interpretar o coeficiente de determinação (^2):

cor(x,y)^2
## [1] 0.9482584

Deste resultado, inferimos que aproximadamente 95% da diminuição do tempo de execução do trabalho está relacionada com o aumento do número de horas do treinamento. Em outras palavras, 95% das variações em y são explicadas por variações em x. Os outros 5% possuem outras causas.

Resposta 1 – d)Trace, no gráfico anterior, a reta de regressão.
z <- plot(x,y) grid(z) #aplicando grid ao gráfico abline(mod) #aplicando reta e regressão ao gráfico para os dados

mod ##
## Call:
## lm(formula = y ~ x, data = dados)
##
## Coefficients:
## (Intercept) x
## 74.90 -11.91

Através dos resultados fornecidos pelo R, concluímos que a equação da reta que melhor aproxima os pontos é = -11,91x+7,90. Além disso, foi traçada a reta de regressão juntamente com o gráfico de dispersão logo abaixo, através do comando abline(mod).

GRÁFICOS EM R

Vamos agora apresentar alguns gráficos simples de se fazer no R. Para não deixarmos os gráficos tão deselegantes a ponto de serem inúteis, vamos incluir algumas características em cada um. A base de dados utilizada será novamente a german_credit_2, que dessa vez será chamada de dados_credito, para não causar confusão.

1. Gráfico de Dispersão: Um dos mais fáceis de se fazer, basta utilizar a função plot(). Você pode fazer com todos os seus dados utilizando simplesmente o comando plot(dados_credito). Porém, como aqui temos diversas colunas, o resultado será ruim de se avaliar. Para facilitar a explicação e visualização, vamos escolher as colunas com a duração do crédito em meses, o montante do crédito e a idade do tomador do empréstimo. No primeiro código vamos mostrar como salvar o gráfico no seu diretório utilizando o jpeg() antes da função que traça o gráfico e o dev.off() após a função, caso você não feche o instrumento você não verá seu gráfico no arquivo salvo:

1
2
3
4
5
6
7
8
9
10
library(xlsx);
dados_credito = read.xlsx("C:/Users/User/Desktop/german_credit_21.xlsx",
1, header=TRUE);
jpeg("../grafico_dispersao.jpeg"); ## guarda a img gerada
plot(dados_credito[, c(5,14)]); ## plota o grafico
dev.off();
## Poderíamos ter trocado dados_credito[, c(5,14)]
## por dados_credito[,c("DurationOfCreditMonth", "CreditAmount")

grafico_dispersao2Se quisermos um gráfico de dispersão com a reta que mais se ajusta aos pontos precisamos utilizar a função abline() e adicionar a reta que queremos. As vezes podemos utilizar simplesmente uma reta horizontal qualquer, caso a gente queira saber se os pontos estão distribuídos ao redor de algum valor. Aqui, queremos saber o comportamento dessas duas informações em conjunto, portanto, utilizaremos uma função de regressão linear:

1
2
3
4
5
6
plot(dados_credito[, c(3,6)]);
abline(lm(CreditAmount~DurationOfCreditMonth, data=dados_credito),
col="red");
## Para tracar uma reta horizontal como explicado acima,
## voce poderia fazer: abline(h=10000, col="red")

dispersao_linha

 

1
2
3
4
## grafico com combinacao de varias variaveis
jpeg("../grafico_dispersao.jpeg");
plot(dados_credito[, c(3,5,14)]);
dev.off();

grafico_dispersao

2. Histograma: Na função plot temos um gráfico que se assemelha a um histograma, mas não é, afinal um histograma é um gráfico de frequência de uma variável. Ele vai apresentar como sua variável está distribuída, se a maioria dos valores se concentra nas pontas, no meio, etc. Para fazer um histograma no R é bem fácil também, basta utilizar a função hist(). Como já é intuitivo para o leitor que o código hist(dados_credito$Age) vai nos retornar um histograma com a distribuição das idades, já vamos incluir o título do gráfico e alterar as cores das barras do histograma. Além disso, temos um exemplo com as quebras que o R tem como padrão, e um segundo com mais quebras utilizando breaks:

1
2
hist(dados_credito$Age, main = "Distribuição das Idades", xlab = "Idade",
ylab = "Frequência", col = 'blue');

hist2

1
2
hist(dados_credito$Age, main = "Distribuição das Idades", xlab = "Idade",
ylab = "Frequência", col = 'blue', breaks=100);

hist3

3. Boxplot: Mais um gráfico que está nos primeiros capítulos de todos os livros de estatística. O boxplot também serve para representar a distribuição dos seus dados. Neste gráfico, fica fácil visualizar onde seus dados estão concentrados porque você consegue ver a posição dos quartis, além dos outliers. No R você pode verificar a distribuição individualmente ou em pares:

1
boxplot(dados_credito$Age, main="Boxplot da Idade");

boxplot

1
2
boxplot(Age~DurationOfCreditMonth,data=dados_credito,
main = "Boxplot Cruzado",xlab="Idade", ylab="Duração do Crédito em Meses");

boxplot2

4. Mapa de Calor (Heatmap): O mapa de calor é uma forma de demonstrar dados bem bacana. Nele, você consegue marcar valores mais altos com uma cor e mais baixos com outra. Muita gente já deve ter utilizado a formatação condicional no excel, que é basicamente a mesma coisa. O mapa de calor no R é interessante para você ver, por exemplo, uma matriz de correlação. Sendo que aqui, você poderá ver os pares com correlação mais forte ou mais fraca de acordo com as cores utilizadas. Vejam dois exemplos com diferentes funções, novamente limitando um pouco nossos dados:

1
2
3
4
5
6
library(ggplot2);
library(reshape2);
colnames(dados_credito)[1:5] = c("Credibilidade","Saldo","Duração","Status",
"Motivo");
qplot(x=X1, y=X2, data=melt(cor(dados_credito[,c(1:5)], use="p")), fill=value,
geom="tile") +scale_fill_gradient2(limits=c(-1, 1));

heatmap1

1
2
3
4
5
6
install.packages("ggplot2")
library(ggplot2);
library(reshape2);
ggplot(data = melt(cor(dados_credito[,c(1:5)], use="p")),
aes(x=X1, y=X2, fill=value)) + geom_tile()+
scale_fill_gradient2(low="darkblue", high="darkgreen", guide="colorbar");

heatmap2

BÔNUS: DIVERSOS GRÁFICOS EM UMA MESMA JANELA

1
2
3
4
5
6
par(mfrow=c(3,2));
plot(dados_credito$Age);
boxplot(dados_credito$Age);
hist(dados_credito$Age);
plot(dados_credito$Age, type = 'l');
plot(dados_credito$Age, type = 'h');

multiple_graph

Fonte : https://estatsite.com

Escrito por : André Yukio

CARREGANDO / IMPORTANDO SEUS DADOS NO R

A função read.table()  do R serve para importar arquivos de diversos formatos. O print abaixo apresenta a descrição do que a função é capaz de fazer e algumas variações dela, como o read.csv() – muito embora a própria read.table() seja capaz de ler arquivos csv.

image

Não tem muito segredo para ler arquivos. Vejamos um exemplo de como ler um arquivo utilizando as principais especificações da função e vamos nomear o arquivo dados_exemplo:

1
dados_exemplo = read.table("C:/Users/Public/Desktop/tabela_exemplo.txt",header=TRUE,sep="\t",dec=",");

Item a item temos:

  • diretório e nome do arquivo;
  • header = TRUE indicando que meu arquivo tem cabeçalho. Se não tivesse, utilizaria header=FALSE;
  • sep=”\t” para indicar separação por tabulações. Poderia ter utilizado sep=”;” ou sep=”,”;
  • dec=”,” foi utilizado para indicar que os dados numéricos são separados por vírgula e não por ponto;

Após os dados serem importados você pode fazer pequenas manutenções (algumas poderiam ser feitas inclusive na hora de importar):

NOMEAR AS COLUNAS

1
colnames(dados_exemplo) = c("NomeDaColuna 1";"NomeDaColuna 2";"NomeDaColuna 3";"NomeDaColuna 4",...)

VISUALIZAR SEUS DADOS

1
2
3
4
5
6
7
8
9
10
## Para abrir a tabela de dados
View(dados_exemplo)
## Para observar as primeiras linhas
head(dados_exemplo)
## Para visualizar da primeira a décima linha, e da primeira a quinta coluna: dados_exemplo[1:10,1:5]
## Para visualizar a primeira linha da coluna 3
dados[1,"NomeDaColuna"]

ORDENAR SEUS DADOS

1
dados_exemplo=dados_exemplo[order(dados_exemplo[,"NomeDaColuna"],decreasing = TRUE),];

ou

1
dados_exemplo$NomeDaColuna = sort(dados_exemplo$NomeDaColuna ,decreasing = TRUE)

Fonte : https://estatsite.com

Escrito por : André Yukio

Lista rápida de pacotes R úteis

Pacotes Recomendados

Muitas funções R úteis vêm em pacotes, bibliotecas livres de código escritas pela comunidade de usuários ativos de R. Para instalar um pacote R, abra uma sessão R e digite na linha de comando

install.packages("<the package's name>")

R irá baixar o pacote do CRAN, então você precisa estar conectado à internet. Uma vez que você tenha um pacote instalado, você pode disponibilizar seu conteúdo para usar em sua sessão R atual executando

library("<the package's name>")

Existem milhares de pacotes R úteis para você usar, mas navegar em todos eles pode ser um desafio. Para ajudá-lo, compilamos este guia para alguns dos melhores. Usamos cada um deles e descobrimos que eles são excelentes – até escrevemos alguns deles. Mas você não precisa acreditar na nossa palavra, esses pacotes também são alguns dos pacotes R mais baixados.

Para carregar dados

RMySQL , RPostgresSQL , RSQLite – Se você quiser ler dados de um banco de dados, esses pacotes são um bom lugar para começar. Escolha o pacote que se adequa ao seu tipo de banco de dados.

XLConnect , xlsx – Esses pacotes ajudam você a ler e gravar arquivos do Microsoft Excel pela R. Você também pode simplesmente exportar suas planilhas do Excel como .csv.

foreign – Deseja ler um conjunto de dados do SAS em R? Ou um conjunto de dados SPSS? Estrangeiro fornece funções que ajudam você a carregar arquivos de dados de outros programas para o R.

R pode manipular arquivos de texto simples – nenhum pacote é necessário. Apenas use as funções read.csv, read.table e read.fwf. Se você tiver dados ainda mais exóticos, consulte o guia do CRAN para importação e exportação de dados.

Para manipular dados

dplyr – Atalhos essenciais para subconjuntos, resumindo, rearranjando e unindo conjuntos de dados. O dplyr é o nosso pacote para manipulação rápida de dados.

tidyr – Ferramentas para alterar o layout de seus conjuntos de dados. Use as funções coletar e distribuir para converter seus dados no formato arrumado , o layout que R gosta melhor.

stringr – Ferramentas fáceis de aprender para expressões regulares e strings de caracteres.

lubridate – Ferramentas que facilitam o trabalho com datas e horários.

Para visualizar dados

ggplot2 – O famoso pacote de R para fazer belos gráficos. O ggplot2 permite que você use a gramática de gráficos para construir gráficos personalizáveis ​​em camadas.

ggvis – Gráficos interativos baseados na web, construídos com a gramática dos gráficos.

rgl – visualizações 3D interativas com R

htmlwidgets – Uma maneira rápida de construir visualizações interativas (baseadas em javascript) com R. Pacotes que implementam htmlwidgets incluem:

 

googleVis – Vamos usar as ferramentas do Google Chart para visualizar dados no R. O Google Chart Tools costumava ser chamado de Gapminder, o software gráfico que Hans Rosling tornou famoso na palestra do TED.

Para modelar dados

A função Anova do carro – carro é popular para fazer tabelas Anova tipo II e tipo III.

mgcv – Modelos Aditivos Generalizados

lme4 / nlme – Modelos de efeitos mistos lineares e não lineares

randomForest – Métodos florestais aleatórios de aprendizado de máquina

multcomp – Ferramentas para testes de comparação múltipla

vcd – Ferramentas de visualização e testes para dados categóricos

glmnet – Métodos de regressão de laço e malha elástica com validação cruzada

survival – Ferramentas para análise de sobrevivência

caret – Ferramentas para treinamento de modelos de regressão e classificação

Para relatar resultados

brilhante – Faça facilmente aplicativos interativos da Web com R. Uma maneira perfeita de explorar dados e compartilhar descobertas com não programadores.

R Markdown – O fluxo de trabalho perfeito para relatórios reproduzíveis. Escreva o código R nos seus  relatórios de remarcação . Quando você executa render, o Markdown R substitui o código por seus resultados e, em seguida, exporta seu relatório como um documento HTML, pdf ou do MS Word ou uma apresentação de slides em HTML ou pdf. O resultado? Relatório automatizado. O Markdown está integrado diretamente no RStudio.

xtable – A função xtable pega um objeto R (como um quadro de dados) e retorna o código HTML ou latex que você precisa para colar uma versão bonita do objeto em seus documentos. Copie e cole ou faça o emparelhamento com o R Markdown.

Para dados espaciais

sp , maptools – Ferramentas para carregar e usar dados espaciais, incluindo shapefiles.

mapas – Fácil usar polígonos de mapa para conspirações.

ggmap – Faça o download de mapas de ruas diretamente dos mapas do Google e use-os como plano de fundo nos seus ggplots.

Para séries temporais e dados financeiros

zoo – Fornece o formato mais popular para salvar objetos de séries temporais em R.

xts – Ferramentas muito flexíveis para manipular conjuntos de dados de séries temporais.

quantmod – Ferramentas para baixar dados financeiros, plotar gráficos comuns e fazer análises técnicas.

Para escrever código R de alto desempenho

Rcpp – Grava funções R que chamam o código C ++ para uma velocidade extremamente rápida.

data.table – Uma maneira alternativa de organizar conjuntos de dados para operações muito, muito rápidas. Útil para dados grandes.

Paralelo – Use o processamento paralelo em R para acelerar seu código ou para processar grandes conjuntos de dados.

Para trabalhar com a web

XML – Leia e crie documentos XML com R

jsonlite – Lê e cria tabelas de dados JSON com R

httr – Um conjunto de ferramentas úteis para trabalhar com conexões http

Para escrever seus próprios pacotes R

devtools – Um conjunto essencial de ferramentas para transformar seu código em um pacote R.

testthat – testthat fornece uma maneira fácil de escrever testes de unidade para seus projetos de código.

roxygen2 – Uma maneira rápida de documentar seus pacotes R. O roxygen2 transforma comentários de código em linha em páginas de documentação e cria um namespace de pacote.

Você também pode ler sobre todo o processo de desenvolvimento de pacotes on-line no livro R Packages de Hadley Wickham. 

Preciso de ajuda?

Os clientes do RStudio Pro podem abrir uma discussão com o Suporte do RStudio a qualquer momento.

Você também pode pedir ajuda aos usuários do R e RStudio em community.rstudio.com. Não se esqueça de incluir um exemplo reproduzível do seu problema.

ESCOLHENDO O DIRETÓRIO NO R

Esse post bem que poderia ser uma continuação do Primeiros passos no R Studio, pois trataremos de algumas coisas que você vai fazer assim que abrir o R e iniciar seus trabalhos, como escolher o diretório em que você vai salvar as figuras ou carregar os dados, saber as dimensões do arquivo externo que você carregou, etc., é bem útil.  É também um pouco repetitivo, já vimos algumas dessas funções separadamente, mas é bom reforçar para quem não viu outros links.

Primeiro, vamos verificar como escolher o diretório em que iremos trabalhar. Isto é, em qual pasta vamos salvar os arquivos ou onde está localizado o arquivo que gostaríamos de carregar no R.

O mais fácil, no point and click do RStudio é ir no Source -> Set working directory -> Choose Directory e digitar a pasta em que estão / devem estar os arquivos relacionados ao projeto que você está trabalhando, como na figura abaixo:

Outra maneira de fazer isso, que eu acho mais elegante, é inserindo alguns comandos no código:

1
2
diretorio = "C:/Users/Yukio/Desktop/Modelo_1";
setwd(diretorio);

Dessa forma, toda vez que eu quiser importar ou salvar um arquivo neste diretório (ou em alguma subpasta existente), eu posso apenas iniciar o caminho com duas reticências:

1
2
3
4
5
6
7
8
## importar o arquivo txt dados na subpasta DataSet
dados = read.table("../dados.txt", header=TRUE);
## salvar o gráfico 1 na pasta Modelo_1
jpeg("../grafico_1")
## salvar o grafico 2 na subpasta Graficos
jpeg("../Graficos/grafico_2")

Agora que você já importou o arquivo, você provavelmente quer saber a quantidade de linhas e colunas, isso pode ser obtido com a função dim():

1
2
## dimensao dos dados (num de linhas e colunas)
dim(dados);

Você terá como resposta dois valores, sendo o primeiro a quantidade de linhas e o segundo a quantidade de colunas. E como visualizar os dados em uma tabela, como se fosse no Excel? Basta utilizar a função View():

1
2
## visualizar o conjunto de dados
View(dados);

Abrirá uma aba, exatamente como um Excel, contendo os dados.

Uma função bem relevante, que eu inclusive vou colocar em outros posts por conta de sua utilidade é a str(). Ela serve para saber o formato de cada variável da sua tabela:

1
2
3
4
5
## formato das variaveis (numeric, factor)
str(dados);
## nome das colunas
col(dados)

Agora que você já carregou seus dados no lugar ideal, você pode começar a tratá-los. Alguns dos posts que podem te ajudar com essa tarefa estão no link Programação em R.

 

 

Fonte : https://estatsite.com

Escrito por : André Yukio

Documentos dinâmicos no R

Criando um documento dinâmico com Markdown e R

No exemplo anterior, escrevemos um documento em Markdown (.md) e inserimos códigos do R, que são apenas apresentados no documento final. Desse forma temos um documento estático, pois os códigos não são interpretados. Para fazermos esse documento ser dinâmico, vamos usar o pacote knitr a nosso favor, fazedo com que ele interprete e retorne resultados dos códigos que inserimos. Vamos denominar genericamente essa combinação de texto em Markdown e códigos do R de “R Markdown”.

Arquivos escritos em R Markdown não podem ser compilados usando ferramentas padrão de conversão de Markdown. O código R deve ser avaliado antes da conversão usando o Pandoc, por exemplo. R Markdown pode ser convertido para Markdown através do knitr. Os resultados de códigos do R são inseridos entre o texto em Markdown, que pode então ser convertido para HTML usando o Pandoc.

O uso do R Markdown para criar documentos dinâmicos tem se tornado uma ferramenta chave atualmente em literate statistical programming, e substituiu largamente ferramentas anteriores como o Sweave.

Os detalhes e opções do pacote knitr serão descritas mais adiante. Por enquanto, o que precisamos fazer para tornar esse documento dinâmico é alterar a extensão do arquivo de .md para .Rmd, e alterar a forma dos blocos de código. Os blocos de códigos (ou chunks) agora devem conter uma marcação especial para indicar que devem ser interpretados pelo R, através do knitr. Para isso, colocamos {r} no início de cada bloco, que agora ficam

```{r}
x <- rnorm(30)
```

Usando o mesmo exemplo anterior, vamos renomear o arquivo Exemplo1.md para Exemplo1-knitr.Rmd e incluir a marção {r} nos blocos de código.

Também é possível colocar códigos do R para serem renderizados na própria linha de texto com `r `. Por exemplo, `r 2+2` gera o resultado 4 no documento.

Veja o arquivo Exemplo1-knitr.Rmd.

# Um documento em Markdown

## Sobre o Markdown

O Markdown é uma linguagem de marcação muito simples, desenvolvida por
John Gruber.

A ideia básica por trás da linguagem é fazer com que o escritor se
preocupe mais com o **conteúdo** do texto do que com a *formatação*.

## Mais um título

Aqui vamos tentar descrever uma análise.

## Simulando variáveis aleatórias

No R podemos simular valores de uma distribuição normal padrão através
da função `rnorm()`.

Seja $X \sim \text{N}(0,1)$, então para gerar 30 valores dessa variável
aleatório normal, fazemos

```{r}
(x <- rnorm(30))
```

## Comentários

Com o resultado dessa simulação, podemos calcular a média e a variância
dessa VA $X$ para conferir se o resultado fica próximo de 0 e 1,
respectivamente.

## Visualização

Também podemos fazer um histograma dessa VA $X$ simulada

```{r}
hist(x)
```

Agora usamos o knitr, através da função knit() para compilar o documento .Rmd em um documento com sintaxe Markdown .md

knit("exemplos/Exemplo1-knitr.Rmd", output = "exemplos/Exemplo1-knitr.md")

O resultado da compilação pode ser vista no arquivo Exemplo1-knitr.md.

# Um documento em Markdown

## Sobre o Markdown

O Markdown é uma linguagem de marcação muito simples, desenvolvida por
John Gruber.

A ideia básica por trás da linguagem é fazer com que o escritor se
preocupe mais com o **conteúdo** do texto do que com a *formatação*.

## Mais um título

Aqui vamos tentar descrever uma análise.

## Simulando variáveis aleatórias

No R podemos simular valores de uma distribuição normal padrão através
da função `rnorm()`.

Seja $X \sim \text{N}(0,1)$, então para gerar 30 valores dessa variável
aleatório normal, fazemos

```r
(x <- rnorm(30))
```

```
##  [1] -0.51874950 -0.27979155  1.00745738 -0.46956995  0.29789704
##  [6] -0.41779443 -0.85038078  0.68904619 -0.46019619  1.34818438
## [11]  0.44307138 -0.15092619  0.45554886 -0.04015468  0.45612104
## [16] -0.40842503 -2.13649386  0.15682192  0.66004890 -0.98183441
## [21] -1.11364370 -0.43734768 -0.51611125  0.41899599  0.13415544
## [26]  1.03468645  1.65350323 -0.01794682 -0.02420332  0.25024690
```

## Comentários

Com o resultado dessa simulação, podemos calcular a média e a variância
dessa VA $X$ para conferir se o resultado fica próximo de 0 e 1,
respectivamente.

## Visualização

Também podemos fazer um histograma dessa VA $X$ simulada

```r
hist(x)
```

![plot of chunk unnamed-chunk-2](figure/unnamed-chunk-2-1.png)

Agora temos um documento em Markdown com os códigos do R avaliados. Mas ainda precisamos processar esse arquivo para gerar o arquivo .html através do Pandoc

pandoc(input = "exemplos/Exemplo1-knitr.md", format = "html")
executing pandoc   -t html -o exemplos/Exemplo1-knitr.html 'exemplos/Exemplo1-knitr_utf8.md'
[1] "exemplos/Exemplo1-knitr.html"

que gera o arquivo Exemplo1-knitr.html que pode ser visualizado no navegador.

R Markdown e knitr

O pacote knitr, como já mencionado, é uma combinação de várias ideias desenvolvidas separadamente em pacotes do R para literate programming, especialmente o Sweave. Este pacote suporta LATEXLATEX, Markdown e HTML como linguagem de documentação, e algumas linguagens de programação, além do R, como por exemplo shell e Python. O resultado destes documentos pode ser exportado para PDF, HTML, ou até mesmo arquivos do MS Word. Daqui em diante, o nosso foco será no uso do knitr com Markdown e R, pela simplicidade e versatilidade dessa linguagem, gerando documentos dinâmicos em HTML. No entanto, a maioria das opções e o funcionamento geral do pacote é similar para LATEXLATEX (e compilação para PDF) e HTML.

Na seção anterior, nós criamos um arquivo com a extensão .Rmd, que é apropriada para documentos escritos em Markdown com R. Nós também usamos as funções knitr() para converter o documento para Markdown, e posteriormente a função pandoc() para gerar o HTML resultante. Esse é o processo básico para gerar documentos dinâmicos no R. No entanto, podemos estender esse processo para incorporar mais controle tanto sob os códigos que são gerados, quanto na apresentação do documento final.

Para facilitar a criação de documentos dinâmicos no R, a equipe do RStudio desenvolveu o pacote rmarkdown, que é baseado no knitr e Pandoc, e contém opções padrão para gerar documentos em vários formatos de maneira mais aprimorada.

A principal função para gerar documentos em R Markdown do pacote rmarkdown é a render(). A função render() é uma wrapper que internamente chama a knitr::knit() e posteriormente converte o documento para .html usando o Pandoc. A diferença é que, além de ser um processo mais direto, a saída em formato HTML utiliza temas mais amigáveis, como o Twitter Bootstrap, que possibilita grandes opções de configuração mais avançada.

Para usar esse função você precisa:

  1. Instalar o pacote rmarkdown com install.packages("rmarkdown")
  2. Instalar o Pandoc no seu sistema

No RStudio, esse pacote já vem instalado, assim como uma versão embutida do Pandoc.

Usando o exemplo anterior, vamos compilar o arquivo Exemplo2-knitr.Rmd. O primeiro argumento da função é o nome (e local) do arquivo, e o segundo argumento é o formato de saída, que por padrão é HTML.

library(rmarkdown)
render("exemplos/Exemplo2-knitr.Rmd",  output_format = "html_document")


processing file: Exemplo2-knitr.Rmd

  |                                                                       
  |                                                                 |   0%
  |                                                                       
  |.............                                                    |  20%
  ordinary text without R code


  |                                                                       
  |..........................                                       |  40%
label: unnamed-chunk-1

  |                                                                       
  |.......................................                          |  60%
  ordinary text without R code


  |                                                                       
  |....................................................             |  80%
label: unnamed-chunk-2

  |                                                                       
  |.................................................................| 100%
  ordinary text without R code
output file: Exemplo2-knitr.knit.md
/usr/bin/pandoc +RTS -K512m -RTS Exemplo2-knitr.utf8.md --to html --from markdown+autolink_bare_uris+ascii_identifiers+tex_math_single_backslash --output /home/fpmayer/GitHub/prr/exemplos/pandoc3d7539f01368.html --smart --email-obfuscation none --self-contained --standalone --section-divs --template /home/fpmayer/R/library/rmarkdown/rmd/h/default.html --variable 'theme:bootstrap' --include-in-header /tmp/RtmpBGUn4C/rmarkdown-str3d754cdd263d.html --mathjax --variable 'mathjax-url:https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML' --no-highlight --variable highlightjs=/home/fpmayer/R/library/rmarkdown/rmd/h/highlight --variable navigationjs=/home/fpmayer/R/library/rmarkdown/rmd/h/navigation-1.1 

Output created: Exemplo2-knitr.html

E o resultado pode ser visto no arquivo Exemplo2-knitr.html.

No RStudio, esse processo todo pode ser feito pelo botão Knit.

Metadados

Uma opção interessante ao utilizar o Pandoc é incluir metados no formato YAML (Yet Another Markup Language). Os metadados em YAML são escritos em formato de lista aninhada, e o Pandoc usa essas informações para incluir, por exemplo, título, autor, e data em um documento.

A opção mais importante para o rmarkdown é o campo output, que permite especificar o formato desejado de saída, o mesmo especificado no argumento output_format = da função render().

Os metadados em YAML são colocados sempre no início de um documento, e são delimitados por ---. Um exemplo típico seria:

---
title: "Meu primeiro documento em R Markdown"
author: "Fernando Mayer & Walmes Zeviani"
date: Maio, 2016
output: html_document
---

Com isso, não é mais necessário especificar o argumento output_format = na chamada da função render().

Veja o arquivo Exemplo1-yaml.Rmd. Para renderizar esse aquivo, usamos:

render("exemplos/Exemplo1-yaml.Rmd")


processing file: Exemplo1-yaml.Rmd

  |                                                                       
  |                                                                 |   0%
  |                                                                       
  |................                                                 |  25%
  ordinary text without R code


  |                                                                       
  |................................                                 |  50%
label: unnamed-chunk-1

  |                                                                       
  |.................................................                |  75%
  ordinary text without R code


  |                                                                       
  |.................................................................| 100%
label: unnamed-chunk-2
output file: Exemplo1-yaml.knit.md
/usr/bin/pandoc +RTS -K512m -RTS Exemplo1-yaml.utf8.md --to html --from markdown+autolink_bare_uris+ascii_identifiers+tex_math_single_backslash --output /home/fpmayer/GitHub/prr/exemplos/pandoc3d751f23de8a.html --smart --email-obfuscation none --self-contained --standalone --section-divs --template /home/fpmayer/R/library/rmarkdown/rmd/h/default.html --variable 'theme:bootstrap' --include-in-header /tmp/RtmpBGUn4C/rmarkdown-str3d7572fc9e14.html --mathjax --variable 'mathjax-url:https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML' --no-highlight --variable highlightjs=/home/fpmayer/R/library/rmarkdown/rmd/h/highlight --variable navigationjs=/home/fpmayer/R/library/rmarkdown/rmd/h/navigation-1.1 

Output created: Exemplo1-yaml.html

O resultado final pode ser visto no arquivo Exemplo1-yaml.html.

Convertendo R Markdown para outros formatos

Por padrão, a função render() gera um arquivo .html, mas existem outros formatos finais possíveis graças ao Pandoc.

O pacote rmarkdown possui uma série de formatos de saída, que possuem os sufixos _document para documentos, e _presentation para apresentações (slides). Alguns deles:

  • Documentos:
    • html_document
    • pdf_document
    • word_document
  • Apresentações:
    • ioslides_presentation
    • slidy_presentation
    • beamer_presentation

Podemos converter um documento em R Markdown para PDF com

render("exemplos/Exemplo1-knitr.Rmd", output_format = "pdf_document")

O resultado é o arquivo Exemplo1-knitr.pdf. A função render() usa o Pandoc para converter Markdown para LATEXLATEX, e depois para PDF.

Um documento do Word pode ser gerado com

render("exemplos/Exemplo1-knitr.Rmd", output_format = "word_document")


processing file: Exemplo1-knitr.Rmd

  |                                                                       
  |                                                                 |   0%
  |                                                                       
  |.............                                                    |  20%
  ordinary text without R code


  |                                                                       
  |..........................                                       |  40%
label: unnamed-chunk-1

  |                                                                       
  |.......................................                          |  60%
  ordinary text without R code


  |                                                                       
  |....................................................             |  80%
label: unnamed-chunk-2
Warning in (knit_hooks$get("plot"))(file, reduce_plot_opts(options)): Chunk
options fig.align, out.width, out.height, out.extra are not supported for
Word output

  |                                                                       
  |.................................................................| 100%
  ordinary text without R code
output file: Exemplo1-knitr.knit.md
/usr/bin/pandoc +RTS -K512m -RTS Exemplo1-knitr.utf8.md --to docx --from markdown+autolink_bare_uris+ascii_identifiers+tex_math_single_backslash --output /home/fpmayer/GitHub/prr/exemplos/pandoc3d7556084288.docx --highlight-style tango 

Output created: Exemplo1-knitr.docx

Para gerar Exemplo1-knitr.docx.

Apresentações em slides HTML podem ser geradas em diversos formatos, um deles é o ioslides

render("exemplos/Exemplo1-knitr.Rmd",
       output_format = "ioslides_presentation",
       output_file = "Exemplo1-knitr-ioslides.html")


processing file: Exemplo1-knitr.Rmd

  |                                                                       
  |                                                                 |   0%
  |                                                                       
  |.............                                                    |  20%
  ordinary text without R code


  |                                                                       
  |..........................                                       |  40%
label: unnamed-chunk-1

  |                                                                       
  |.......................................                          |  60%
  ordinary text without R code


  |                                                                       
  |....................................................             |  80%
label: unnamed-chunk-2

  |                                                                       
  |.................................................................| 100%
  ordinary text without R code
output file: Exemplo1-knitr.knit.md
/usr/bin/pandoc +RTS -K512m -RTS Exemplo1-knitr.utf8.md --to html --from markdown+autolink_bare_uris+ascii_identifiers+tex_math_single_backslash --output /home/fpmayer/GitHub/prr/exemplos/pandoc3d7568309a32.html --smart --email-obfuscation none --self-contained --variable transition=0.4 --template /home/fpmayer/R/library/rmarkdown/rmd/ioslides/default.html --mathjax --variable 'mathjax-url:https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML' --variable ioslides-url=/home/fpmayer/R/library/rmarkdown/rmd/ioslides/ioslides-13.5.1 
/usr/bin/pandoc +RTS -K512m -RTS Exemplo1-knitr.utf8.md --to ioslides_presentation.lua --from markdown+autolink_bare_uris+ascii_identifiers+tex_math_single_backslash --output /tmp/RtmpBGUn4C/ioslides-output3d75321cc3bd.html --slide-level 2 

Output created: Exemplo1-knitr-ioslides.html

Veja o resultado em Exemplo1-knitr-ioslides.html.

Apresentações em Beamer também podem ser geradas com

render("exemplos/Exemplo1-knitr.Rmd",
       output_format = "beamer_presentation",
       output_file = "Exemplo1-knitr-beamer.pdf")

Com resultado no arquivo Exemplo1-knitr-beamer.pdf.

Opções do knitr

O pacote knitr possui diversas opções para controlar a saída dos resultados de códigos do R. Estas opções funcionam igualmente em blocos de código inseridos entre texto escrito em Markdown ou LATEXLATEX.

Para controlar a saída de código de um único chunk, coloque as opções individualmente

```{r, opt1=val1, opt2=val2}
# código
```

Para controlar globalmente todos os chunks de um documento, use a função knitr::opts_chunk$set():

```{r, echo=FALSE}
knitr::opts_chunk$set(opt1 = val1,
                      opt2 = val2
)
```

As opções mais importantes são:

  • eval = FALSE para não avaliar o código, apenas mostrar
  • echo = FALSE para não mostrar o código, apenas as saídas
  • results = "hide" para não mostrar as saídas
  • warning = FALSE e message = FALSE para suprimir as mensagens de aviso
  • fig.width = 5 and fig.height = 5 para alterar o tamanho dos gráficos gerados pelo R (em polegadas)
  • cache = TRUE para armazenar os resultados, e evitar com que eles sejam executados todas as vezes que o documento é compilado

Tabelas podem ser também geradas automaticamente a partir de resultados de funções do R. Para gerar uma tabela a partir de um objeto do R, podemos usar a função knitr::kable(). Para isso, também é necesário utilizar a opção results = "asis" no chunk, para que o resultado seja tratado como texto literal em Markdown.

```{r, results="asis"}
kable(head(iris))
```
Sepal.Length Sepal.Width Petal.Length Petal.Width Species
5.1 3.5 1.4 0.2 setosa
4.9 3.0 1.4 0.2 setosa
4.7 3.2 1.3 0.2 setosa
4.6 3.1 1.5 0.2 setosa
5.0 3.6 1.4 0.2 setosa
5.4 3.9 1.7 0.4 setosa

A lista completa de opções está em http://yihui.name/knitr/options.

Utilizando a opção output: um cabeçalho YAML, podemos informar mais de um formato para ser gerado ao mesmo tempopelo rmarkdown. Por exemplo, para gerar documentos de saída em HTML e PDF, podemos especificar

---
title: "Meu primeiro documento em R Markdown"
author: "Fernando Mayer & Walmes Zeviani"
date: Maio, 2016
output: html_document
output:
  html_document: default
  pdf_document: default
---

E compilar todos eles ao mesmo tempo com

render("exemplos/Exemplo1-yaml2.Rmd", output_format = "all")

Veja Exemplo1-yaml2.html, e Exemplo1-yaml2.pdf.


Licença Creative Commons 4.0

Este conteúdo está disponível por meio da Licença Creative Commons 4.0

COMANDOS BÁSICOS DO SISTEMA R

COMANDOS BÁSICOS DO SISTEMA R
Baseado no material do Mauro Campos, fiz uma seleção de alguns dos comandos básicos. As palavras que aparecem em azul, devem ser substituidas pelo comando ou nome específico.

Ajuda do R
help(comando)– Ajuda rápida sobre um comando
help.start() – Inicia a ajuda no browser
help(package=nome_pacote) – Ajuda sobre um pacote

Carregando Dados e Bibliotecas
Pacotes e bibliotecas no R são a mesma coisa. Note que os dois primeiros comandos abaixo têm a mesma função.

require(nome_pacote) – Carregar um pacote
library (nome_pacote) – Carregar um pacote
data(nome_dos_dados) – Carregar um conjunto de dados

Entradas e Saídas
source(“arquivo“) – Roda os comandos de um arquivo
read.table(“arquivo“) – Lê os comandos de um arquivo
scan(“arquivo“)– Lê um arquivo como vetor
write(object,”arquivo“) – Grava um objeto do R em um arquivo
write.table(data.frame,”arquivo“) – Grava uma tabela em um arquivo

Trabalhando com Objetos e Variáveis
ls() – Lista todos objetos disponíveis
rm(object) – Remove um objeto
remove(list=ls()) – Remove TODOS os objetos
dimnames(matrix)– Nomes das dimensões de uma matriz
length(nome_vetor) – Comprimento de determinado vetor

Algumas Operações Aritméticas
^, ** – Potência
/,+,-,* – Divisão, adição, subtração,multiplicação
sqrt – Raiz quadrada
abs – Valor absoluto (positivo)

Algumas Funções Matemáticas
sin cos tan – Funções trigonométricas
asin acos atan – Funções trigonométricas inversas
sinh cosh tanh – Funções hiperbólicas
asinh acosh atanh – Funções hiperbólicas inversas
exp log – Exponencial e logarítmo natural
log10 – Logarítmo base 10

Estatísticas
max() – Máximo
min() – Mínimo
mean() – Média
median() – Mediana
sum() – Soma
summary(data.frame) – Resumo das Estatísticas
rank() – Posição
sort() – Ordenação

Eu sei que provavelmente algumas das coisas descritas acima podem soar um tanto confusas. O R é um sistema estatatístico bastante complexo. Em postagens futuras vou explicar com mais detalhes sobre os conceitos ligados ao R, tais como “data.frames” e mostrar exemplos mais práticos de sua aplicação no ramo da Geoinformação.

Tutorial de ggplot2

O pacote ggplot2 foi desenvolvido pelo Dr. Hadley Wickham (que desenvolveu diversos outros pacotes importantes para R como o (d)plyr por exemplo. Este pacote implementa uma nova maneira de criar gráficos a partir dos dados, trazendo o conceito de camadas (layers) para a sintaxe do R. Com esse novo conceito, surge também a necessidade de se organizar os dados de uma maneira que facilite a utilização da nova sintaxe. Para isso, os outros pacotes (como os já mencionados (d)plyr) foram desenvolvidos pelo Dr. Wickham de maneira a tornar a manipulação de dados mais ágil, intuitiva e já adequada para o uso conjunto com ggplot2.

Instalação
O pacote deve ser instalado como qualquer outro pacote no R:

install.packages(“ggplot2”)
É possível também instalar as versões mais recentes do pacote (mas que podem apresentar instabilidades ou serem incompletas) através da função install_github do pacote devtools. Este tipo de instalação usa os arquivos disponíveis no repositório público do ggplot2 no github.

install.packages(“devtools”)
library(devtools)
install_github(“hadley/ggplot2”)
Após a instalação, carregue o pacote para utilização.

library(ggplot2)
Como organizar os dados para o ggplot2
É bastante comum usuários enfrentarem problemas nas primeiras vezes que usam o ggplot2 pois ao organizarem os dados para serem importados no R, procuram o fazer da maneira mais sintética possivel, agrupando variáveis por exemplo. A tabela a seguir é um exemplo de como NÃO se deve organizar os dados para serem usados com o ggplot2 (para nenhuma situação na verdade).

## Tratamento Valor
## 1 Tratamento A – 2h 10.821762
## 2 Tratamento A – 4h 10.306185
## 3 Tratamento A – 8h 10.608959
## 4 Tratamento A – 16h 9.023300
## 5 Tratamento A – 24h 9.098674
## 6 Tratamento B – 2h 10.875956
## 7 Tratamento B – 4h 9.560360
## 8 Tratamento B – 8h 10.117291
## 9 Tratamento B – 16h 10.575051
## 10 Tratamento B – 24h 10.787699
Os objetos de entrada nas funções do ggplot2 são da classe data.frame. No entanto, organizar o data.frame de maneira a otimizar o trabalho poupa bastante tempo e dor de cabeça. O data.frame a ser usado em um trabalho deve idealmente conter cada uma das variáveis em colunas separadas, e cada observação em linhas separadas. Assim, o exemplo anterior deveria ser idealmente organizado da seguinte forma:

## Valor Tempo Tratamento
## 1 10.821762 2 Tratamento A
## 2 10.306185 4 Tratamento A
## 3 10.608959 8 Tratamento A
## 4 9.023300 16 Tratamento A
## 5 9.098674 24 Tratamento A
## 6 10.875956 2 Tratamento B
## 7 9.560360 4 Tratamento B
## 8 10.117291 8 Tratamento B
## 9 10.575051 16 Tratamento B
## 10 10.787699 24 Tratamento B
Alguns pacotes foram desenvolvidos com o propósito de facilitar a organização dos dados de maneira limpa e otimizada. Dentre esses pacotes, encontram-se (d)plyr, tidyr, magrittr dentre outros. Para mais informações sobre como (e porquê) organizar seus dados dessa forma, leia este artigo do Dr. Wickham.

Estrutura básica de um gráfico
Como dito na introdução, um gráfico feito no ggplot2 consiste de diversas camadas que são adicionadas a uma estrutura básica. Essa estrutura básica é criada usando as funções ggplot ou qplot. Essas funções possuem dois componentes essenciais: data, que como o nome diz recebe o data.frame a ser utilizado para a construção do gráfico, e mapping, que é o argumento que controla a estética do gráfico, ou seja, que controla quais variáveis serão plotadas nos eixos x e y, dentre outros detalhes que serão abordados posteriormente. Para o mapeamento dos dados, usaremos a função aes, na qual indicaremos qual variável deve ser posicionada em cada eixo, além de outros argumentos relativos a cor, tamanho, etc.

Diogo Melo, do Laboratório de Evolução de Mamíferos do IB-USP sintetizou uma regra geral para gráficos no ggplot2:

ggplot(data_frame_entrada, aes(x = coluna_eixo_x,
y = coluna_eixo_y,
group = coluna_agrupadora,
color = coluna_das_cores))
+ geom_tipo_do_grafico(opções que não dependem dos dados,
aes(opções que dependem))
Para exemplificar a construção de um gráfico, usaremos o conjunto de dados do próprio pacote ggplot2 chamado diamonds.

data(diamonds)
head(diamonds)
## carat cut color clarity depth table price x y z
## 1 0.23 Ideal E SI2 61.5 55 326 3.95 3.98 2.43
## 2 0.21 Premium E SI1 59.8 61 326 3.89 3.84 2.31
## 3 0.23 Good E VS1 56.9 65 327 4.05 4.07 2.31
## 4 0.29 Premium I VS2 62.4 58 334 4.20 4.23 2.63
## 5 0.31 Good J SI2 63.3 58 335 4.34 4.35 2.75
## 6 0.24 Very Good J VVS2 62.8 57 336 3.94 3.96 2.48
Gráficos unidimensionais (boxplots e histogramas)
Um bom modo de iniciar qualquer análise é fazendo uma análise exploratória dos dados. Para isso, alguns tipos específicos de gráficos como boxplots ou histogramas são maneiras simples de visualizar a estrutura básica dos dados. Estes tipos de gráfico são ditos unidimensionais, pois representam apenas uma variável. Neste tópico, veremos como criar esses dois gráficos de maneira simples (complementos serão adicionados mais para frente no tutorial).

O primeiro passo para criarmos um gráfico é então gerar o objeto da classe ggplot. DICA: armazene as camadas básicas do seu gráfico em um objeto, pois isso facilita a adição de novas camadas sem a necessidade de repetir o código inteiro.

g1 <- ggplot(data=diamonds,aes(x=1,y=price)) No exemplo acima, indicamos que a variável price deve ser atribuída ao eixo y, e o eixo x recebe o valor 1 apenas para posicionar o gráfico. Além disso o código que acabamos de rodar serve apenas para criar um objeto da classe ggplot, porém ele ainda não produz nenhum gráfico. Ao chamarmos o objeto g1: ## Error: No layers in plot Isso se deve ao fato de que nenhuma camada de gráfico foi adicionada, ou seja, não especificamos qual o tipo de gráfico desejamos produzir. A maioria das camadas iniciais podem ser criadas usando as funções da família geom_. No primeiro exemplo, vamos criar um boxplot para termos uma ideia de valores mínimos, máximos, média e posição dos quartis. g1 + geom_boxplot() Note a sintaxe bastante intuitiva que usa o símbolo “+” para adicionar camadas. Isso torna o ggplot2 um pacote bastante prático depois de pegar o jeito para criar gráficos informativos, bonitos e prontos para publicação. Para criarmos um histograma simples, é igualmente fácil: ggplot(diamonds,aes(x=price)) + geom_histogram() ## stat_bin: binwidth defaulted to range/30. Use 'binwidth = x' to adjust this. Observe no entanto que para o histograma a variável de interesse está no eixo x, já que o eixo y contém a contagem de valores em cada intervalo. Os gráficos básicos podem não parecer tão bonitos assim à primeira vista; vamos aprender em seções posteriores como modificar a estética dos gráficos (cores, tamanho, bordas, plano de fundo, etc.). Gráficos bidimensionais (gráficos de dispersão, modelos lineares, etc.) Gráficos de dispersão Em grande parte dos estudos em ecologia buscamos analisar como duas ou mais variáveis se comportam umas em relação às outras. Para isso, um bom ponto de partida é construir gráficos de dispersão (scatterplots). No exemplo a seguir construiremos um gráfico de dispersão entre as variáveis carat e price. g2 <- ggplot(diamonds,aes(x=carat,y=price)) g2 + geom_point() Note que no exemplo acima, estamos indicando para a função ggplot que as camadas que forem adicionadas de agora em diante devem conter os valores de carat no eixo x e de price no eixo y. Isso pode ser modificado posteriormente (como nos casos onde você quer por exemplo acrescentar uma outra variável no eixo y), e será exemplificado mais adiante. No entanto, a maioria (se não todas) das funções da família geom_ também possuem os argumentos básicos data e mapping. Sendo assim, uma outra forma de criar o mesmo gráfico é: ggplot() + geom_point(data=diamonds,mapping=aes(x=carat,y=price)) Caso a cor padrão seja feia não seja adequada, podemos indicar para o gráfico qual cor queremos usar para os pontos. Como cor é um dos componentes essenciais da parte estética de um gráfico, essa especificação deve entrar na função aes. g2 + geom_point(mapping=aes(colour="red")) Ao analisarmos o conteúdo do objeto diamonds notamos que os valores de carat e price são divididos por classe de cut, color e clarity. Assim, podemos por exemplo representar o mesmo conjunto de dados separados por classe de clarity por exemplo. Se seu objeto contendo os dados estiver mal organizado, você levaria um tempo razoável para adicionar uma cada para cada classe cada uma com uma cor diferente. Porém, como já aprendemos a organizar nossos dados de maneira idea, podemos facilmente usar a variável clarity para atribuir diferentes cores que representarão cada uma das classes da seguinte forma: g2 + geom_point(mapping=aes(colour=clarity)) Essa separação em classes de clarity pode ser feita em outros tipos de gráfico também (os outliers foram removidos para fins de visualização): ggplot(data=diamonds, aes(x=clarity, y=price, group=interaction(clarity,cut), color=clarity)) + geom_boxplot(outlier.shape=NA) Adicionando linhas de tendência Os gráficos de dispersão que construímos até agora indicam que existe uma relação positiva entre quilates e preço. Nesse caso, podemos ajustar um modelo linear que indique como se dá essa correlação. Para isso, o pacote ggplot2 possui funções específicas para algumas estatísticas comumente usadas. Aqui, usaremos a função stat_smooth para isso. g2 + geom_point(aes(color=clarity)) + geom_smooth(method = "lm", se=FALSE, aes(color="red")) A linha de regressão adicionada no gráfico anterior corresponde à correlação entre carat e price indepentende da classe de clarity. Porém, dependendo do caso pode ser mais interessante criar uma reta de correlação para cada classe de clarity. Fazemos isso da seguinte forma (adicionando também intervalos de confiança da média): g3 <- g2 + geom_point(aes(color=clarity)) + geom_smooth(method = "lm", se=TRUE, aes(color=clarity)) g3 Personalizando os gráficos Alterar rótulos dos eixos g3 + xlab("Quilates") + ylab("Preco") Alterar limites dos eixos g3 + xlim(0,10) + ylim(0,30000) Alterar tamanho e direção das fontes dos eixos g3 + theme(axis.text.x = element_text(angle=45,vjust=1,size=30)) Inserir anotações g3 + xlim(0,10) + ylim(0,30000) + annotate("text",x=9.5,y=30000,label= "Painel a",color="red") g3 + xlim(0,10) + ylim(0,30000) + annotate("rect",xmin=3, xmax=4, ymin=10000, ymax=20000, alpha=.2, color="blue",fill="green") g3 + xlim(0,10) + ylim(0,30000) + annotate("segment", x=3, xend=4, y=30000, yend=20000, color="orange", arrow=arrow(length=unit(1,"cm"))) Alterar paleta de cores g2 + geom_point(aes(color=clarity)) + scale_color_brewer(type="seq",palette="Set3") Separar gráficos em painéis g2 + geom_point(aes(color=clarity)) + facet_grid(. ~ cut) g2 + geom_point(aes(color=clarity)) + facet_grid(cut ~ .) g2 + geom_point(aes(color=clarity)) + facet_grid(cut ~ clarity) Alterar posição, título e tamanho da legenda g3 + xlim(0,10) + ylim(0,30000) + theme(legend.position = "none") g3 + xlim(0,10) + ylim(0,30000) + theme(legend.position = "bottom") g3 + xlim(0,10) + ylim(0,30000) + theme(legend.position = "bottom", legend.title = element_blank()) g3 + xlim(0,10) + ylim(0,30000) + theme(legend.position = c(.8,.8)) g3 + xlim(0,10) + ylim(0,30000) + theme(legend.position = c(.8,.2)) Alterar temas g3 + theme_bw() g3 + theme(panel.grid.major = element_line(colour = "red", linetype = "dotted"), panel.background = element_rect(fill = "green")) Principais tipos de gráfico Tipo de gráfico Função Histograma geom_histogram Densidade geom_density Boxplot geom_boxplot Barras geom_bar Polígonos geom_polygon Abline geom_abline Texto geom_text

Como fazer uma análise de regressão linear simples no R

null

A análise de regressão é normalmente utilizada quando se deseja obter um modelo preditivo do efeito de uma variável sobre outra sendo que essas variáveis devem ser contínuas. Na Regressão Linear Simples têm-se apenas duas variáveis, uma variável preditora (eixo X) e outra resposta (eixo y).

Existem quatro pressupostos básicos para análises de regressão:

LINEARIDADE (o modelo linear descreve corretamente a relação funcional entre X e Y)
Se esse pressuposto for violado a estimativa do erro aumentará, já que os valores observados não se aproximarão dos valores preditos (local onde passará a reta). Pressuposto fundamental já que essa regressão é um modelo linear.
VARIÁVEL PREDITORA MEDIDA SEM ERROS
Garante que a variação observada na análise é devido apenas à sua associação com a variável resposta Esse pressuposto tem sido ignorado devido a eficiência da solução dos mínimos quadrados.

NORMALIDADE
Normalidade dos resíduos é esperada para que não existam tendências e que a estatística F funcione de forma correta.

VARIÂNCIAS HOMOGÊNEAS
As variâncias dentro de cada grupo é igual (ou pelo menos aproximadamente) àquela dentro de todos os grupos. Desta forma, cada tratamento contribui de forma igual para a soma dos quadrados.

Se os pressupostos forem atendidos fica mais fácil afirma que os resultados da análise são devido aos efeitos testados. Além disso, a confiabilidade do teste aumenta, já que se terá certeza que não há tendências nos resultados.

Segue um scrip para a realização da regressão linear simples no R (em verde são os comentários):

#Primeiramente, vamos criar dois conjuntos de dados (“x” e “y”) apenas para realizar o exemplo
x< -c(1,2,3,4,5,6,7,8,9,10) y<-c(2,5,8,5,3,9,10, 12, 9, 10)

#A função para regressão é “lm” e não requer pacote estatístico (variavel resposta ~ variável preditora)
resmodelo<-lm(x~y) #Sumário dos resultados do modelo summary(resmodelo)

#Teste para NORMALIDADE (valores de p > 0,05 indicam dados normais)
shapiro.test(rstudent(resmodelo)) ##teste de shapiro wilk (normalidade)

# Análise visual para homogeneidade dos resíduos
(visualmente eles devem se distribuir igualmente #abaixo e acima da linha)
plot(rstudent(resmodelo) ~ fitted(resmodelo), pch = 19)
abline(h = 0, lty = 2)

#Visualização gráfica lty é o tipo da linha 1: linha contínua; 2: linha descontínua
plot(x~y)
abline(resmodelo,lty=2)

Ao digitar todas essas linhas de comando, o resultado final deverá ser um R2 ajustado = 0,55. Para montar a equação é necessário pegar o valor do intercepto e da inclinação: y = 0,3586 + 0,7043x. Além disso, por meio do teste de Shapiro Wilk (W) é possível atestar a normalidade dos dados (p = 0,33) e através da inspeção visual dos resíduos verifica-se que os mesmos distribuem-se de forma igual.

Um dos principais resultados da regressão é o R2, que é o coeficiente de determinação. Esse valor varia de -1 a 1 (repostas positivas e negativas) e indica o grau de associação entre as duas variáveis testadas. Já o parâmetro da inclinação demonstra o quanto a variável resposta varia em função da preditora. Desta forma, uma inclinação igual a zero indicaria a falta de associação entre elas.