Fluxo de trabalho para análise estatística e elaboração de relatórios

Alguém tem alguma noção dos fluxos de trabalho para análise de dados relacionados à elaboração de relatórios personalizados? O caso de uso é basicamente este:

1. O cliente envia um relatório que utiliza análise de dados, por exemplo, uma estimativa populacional e mapas relacionados a um distrito de água.

2. O analista baixa alguns dados, mescla os dados e salva o resultado (por exemplo, adicionando uma coluna para população por unidade ou subconjuntando os dados com base nos limites do distrito).

3. O analista analisa os dados criados em (2), aproxima-se de seu objetivo, mas vê que precisa de mais dados e volta para (1).

4. Enxágue repetidamente até que as tabelas e gráficos atendam ao controle de qualidade / qualidade e satisfaçam o cliente.

5. Escreva um relatório incorporando tabelas e gráficos.

6. No próximo ano, o cliente satisfeito volta e quer uma atualização. Isso deve ser tão simples quanto atualizar os dados upstream com um novo download (por exemplo, obter as licenças de construção do ano passado) e pressionar um botão "RECALCULAR", a menos que as especificações mudem.

No momento, apenas inicio um diretório e ad-hoc o melhor que posso. Gostaria de uma abordagem mais sistemática, por isso espero que alguém tenha entendido isso ... Uso uma mistura de planilhas, SQL, ARCGIS, R e ferramentas Unix.

Obrigado!

PS:

Abaixo está um Makefile básico que verifica dependências em vários conjuntos de dados intermediários (com .RDatasufixo) e scripts ( .Rsufixo). O Make usa registros de data e hora para verificar as dependências; portanto, se você touch ss07por.csv, ele verá que esse arquivo é mais novo que todos os arquivos / destinos que dependem dele e executará os scripts fornecidos para atualizá-los adequadamente. Este ainda é um trabalho em andamento, incluindo uma etapa para inserção no banco de dados SQL e uma etapa para uma linguagem de modelagem como sweave. Observe que o Make depende de guias em sua sintaxe; portanto, leia o manual antes de cortar e colar. Aproveite e dê feedback!

http://www.gnu.org/software/make/manual/html_node/index.html#Top

R = / home / wsprague / R-2.9.2 / bin / R

persondata.RData: ImportData.R ../../DATA/ss07por.csv Functions.R
   $ R --slave -f ImportData.R

persondata.Munged.RData: MungeData.R persondata.RData Functions.R
      $ R --slave -f MungeData.R

report.txt: TabulateAndGraph.R persondata.Munged.RData Functions.R
      $ R --slave -f TabulateAndGraph.R> report.txt

Geralmente, divido meus projetos em quatro partes:

1. load.R
2. clean.R
3. func.R
4. do.R

load.R: cuida do carregamento de todos os dados necessários. Normalmente, este é um arquivo curto, que lê dados de arquivos, URLs e / ou ODBC. Dependendo do projeto, neste momento, escreverei a área de trabalho usando save()ou manterei as coisas na memória para a próxima etapa.

clean.R: É aqui que vivem todas as coisas feias - cuidando dos valores que faltam, mesclando quadros de dados, lidando com outliers.

func.R: Contém todas as funções necessárias para executar a análise real. source()Esse arquivo não deve ter efeitos colaterais além de carregar as definições de função. Isso significa que você pode modificar esse arquivo e recarregá-lo sem precisar voltar às etapas 1 e 2 repetidas, o que pode levar muito tempo para ser executado em grandes conjuntos de dados.

do.R: Chama as funções definidas em func.R para executar a análise e produzir gráficos e tabelas.

A principal motivação para essa configuração é trabalhar com dados grandes, nos quais você não deseja recarregar os dados toda vez que fizer uma alteração em uma etapa subsequente. Além disso, manter meu código compartimentado dessa maneira significa que eu posso voltar para um projeto esquecido e ler rapidamente o load.R, descobrir quais dados eu preciso atualizar e depois analisar o do.R para descobrir qual análise foi executada.

Se você quiser ver alguns exemplos, tenho alguns projetos pequenos (e não tão pequenos) de limpeza e análise de dados disponíveis on-line. Na maioria dos casos, você encontrará um script para baixar os dados, um para limpá-los e alguns para explorar e analisar:

• Nomes de bebês da administração de seguridade social
• Mais de 30 anos de dados de economia de combustível do EPI
• Uma grande coleção de dados sobre a crise imobiliária
• Classificações de filmes do IMDB
• Dados de venda de moradias na área da baía

Recentemente, comecei a numerar os scripts, por isso é completamente óbvio em que ordem eles devem ser executados. (Se estou me sentindo realmente elegante, às vezes faço com que o script de exploração chame o script de limpeza, que por sua vez chama o script de download, cada um fazendo o trabalho mínimo necessário - geralmente verificando a presença de arquivos de saída file.exists. No entanto, na maioria das vezes isso parece exagero).

Eu uso o git para todos os meus projetos (um sistema de gerenciamento de código-fonte) para facilitar a colaboração com outras pessoas, ver o que está mudando e reverter facilmente para as versões anteriores.

Se eu faço um relatório formal, geralmente mantenho R e látex separados, mas sempre me certifico de que posso usar sourcemeu código R para produzir todo o código e saída necessários para o relatório. Para os tipos de relatórios que eu faço, acho isso mais fácil e limpo do que trabalhar com látex.

Concordo com os outros respondentes: Sweave é excelente para escrever relatórios com R. E reconstruir o relatório com resultados atualizados é tão simples quanto chamar novamente a função Sweave. É completamente independente, incluindo todas as análises, dados, etc. E você pode controlar a versão do arquivo inteiro.

Eu uso o plugin StatET do Eclipse para desenvolver os relatórios e o Sweave é integrado (o Eclipse reconhece a formatação de látex, etc.). No Windows, é fácil usar o MikTEX .

Eu também acrescentaria que você pode criar relatórios bonitos com o Beamer . Criar um relatório normal é igualmente simples. Incluí um exemplo abaixo que extrai dados do Yahoo! e cria um gráfico e uma tabela (usando quantmod). Você pode criar este relatório da seguinte maneira:

Sweave(file = "test.Rnw")

Aqui está o próprio documento Beamer:

% 
\documentclass[compress]{beamer}
\usepackage{Sweave}
\usetheme{PaloAlto} 
\begin{document}

\title{test report}
\author{john doe}
\date{September 3, 2009} 

\maketitle

\begin{frame}[fragile]\frametitle{Page 1: chart}

<<echo=FALSE,fig=TRUE,height=4, width=7>>=
library(quantmod)
getSymbols("PFE", from="2009-06-01")
chartSeries(PFE)
@

\end{frame}


\begin{frame}[fragile]\frametitle{Page 2: table}

<<echo=FALSE,results=tex>>=
library(xtable)
xtable(PFE[1:10,1:4], caption = "PFE")
@

\end{frame}

\end{document}

Eu só queria acrescentar, caso alguém tenha perdido, que há um ótimo post no blog learnr sobre a criação de relatórios repetitivos com o pacote de cervejas de Jeffrey Horner . Matt e Kevin mencionaram a bebida acima. Na verdade, eu não usei muito isso.

As entradas seguem um bom fluxo de trabalho, portanto vale a pena ler:

1. Prepare os dados.
2. Prepare o modelo de relatório.
3. Produza o relatório.

Na verdade, a produção do relatório após a conclusão das duas primeiras etapas é muito simples:

library(tools)
library(brew)
brew("population.brew", "population.tex")
texi2dvi("population.tex", pdf = TRUE)

Para criar relatórios personalizados, achei útil incorporar muitas das dicas existentes sugeridas aqui.

Gerando relatórios: Uma boa estratégia para gerar relatórios envolve a combinação de Sweave, make e R.

Editor: bons editores para a preparação de documentos Sweave incluem:

• StatET e Eclipse
• Emacs e ESS
• Vim e Vim-R
• R Studio

Organização de código: Em termos de organização de código, considero duas estratégias úteis:

• Leia sobre o fluxo de trabalho de análise (por exemplo, ProjectTemplate , as idéias de Josh Reich, minha própria apresentação nos slides e vídeo do fluxo de trabalho R )
• Estudar relatórios de exemplo e discernir o fluxo de trabalho
  • Exemplos de Hadley Wickham
  • Meus exemplos no github
  • Exemplos de pesquisas reproduzíveis listadas no Cross Validated

Eu uso o Sweave no lado de produção de relatórios, mas também tenho ouvido falar sobre o pacote de fermentação - embora ainda não o tenha examinado.

Essencialmente, tenho várias pesquisas para as quais produzo estatísticas resumidas. Mesmas pesquisas, mesmos relatórios sempre. Criei um modelo Sweave para os relatórios (o que exige um pouco de trabalho). Mas, uma vez concluído o trabalho, tenho um script R separado que me permite apontar os novos dados. Pressiono "Go", o Sweave despeja alguns arquivos .tex, e corro um pequeno script Python para pdflatex todos. Meu antecessor passava ~ 6 semanas por ano nesses relatórios; Passo cerca de três dias (principalmente na limpeza de dados; caracteres de escape são perigosos).

É muito possível que haja abordagens melhores agora, mas se você decidir seguir esse caminho, avise-me - eu pretendo colocar alguns dos meus hacks Sweave, e isso seria um bom chute nas calças. tão.

Vou sugerir algo em uma direção diferente dos outros remetentes, com base no fato de que você perguntou especificamente sobre o fluxo de trabalho do projeto , em vez de ferramentas . Supondo que você esteja relativamente satisfeito com seu modelo de produção de documentos, parece que seus desafios podem estar mais centrados em questões de rastreamento de versão, gerenciamento de ativos e processo de revisão / publicação.

Se isso parecer correto, sugiro procurar uma ferramenta integrada de gerenciamento de bilhetes / documentação / documentação como o Redmine . Manter artefatos de projetos relacionados, como tarefas pendentes, encadeamentos de discussão e arquivos de dados / código com versão juntos, pode ser uma grande ajuda, mesmo para projetos bem fora do bailiwick de "programação" tradicional.

Concordou que o Sweave é o caminho a seguir, com o xtable para gerar tabelas LaTeX. Embora eu não tenha passado muito tempo trabalhando com eles, o pacote tikzDevice, lançado recentemente , parece realmente promissor, principalmente quando associado ao pgfSweave (que, até onde eu sei, só está disponível no rforge.net no momento - existe um link para r-forge a partir daí, mas não está respondendo para mim no momento).

Entre os dois, você terá uma formatação consistente entre texto e figuras (fontes, etc.). Com a fermentação, estes podem constituir o santo graal da geração de relatórios.

Em um nível mais "meta", você pode estar interessado no modelo de processo CRISP-DM .

"make" é ótimo porque (1) você pode usá-lo para todo o seu trabalho em qualquer idioma (ao contrário, digamos, Sweave and Brew), (2) é muito poderoso (o suficiente para criar todo o software em sua máquina) e (3) evita repetir o trabalho. Este último ponto é importante para mim, porque muito do trabalho é lento; quando coloco um arquivo em latex, gosto de ver o resultado em alguns segundos, e não a hora que levaria para recriar as figuras.

Eu uso modelos de projeto junto com o R studio, atualmente o meu contém as seguintes pastas:

• info : pdfs, powerpoints, documentos ... que não serão usados ​​por nenhum script
• data input : dados que serão usados ​​pelos meus scripts, mas não gerados por eles
• data output : dados gerados pelos meus scripts para uso posterior, mas não como um relatório adequado.
• reports : Apenas arquivos que serão realmente mostrados a outra pessoa
• R : Todos os scripts R
• SAS : Porque às vezes tenho que: '(

Escrevi funções personalizadas para poder chamar smart_save(x,y)ou smart_load(x)salvar ou carregar RDS filespara e da data outputpasta (arquivos nomeados com nomes de variáveis) para não me incomodar pathsdurante a análise.

Uma função personalizada new_projectcria uma pasta de projeto numerada, copia todos os arquivos do modelo, renomeia o RProjarquivo e edita as setwdchamadas e define o diretório de trabalho para o novo projeto.

Todos os Rscripts estão na Rpasta, estruturados da seguinte maneira:

00_main.R

• setwd
• chama scripts 1 a 5

00_functions.R

• Todas as funções e apenas as funções vão para lá, se houver muitas, eu a separarei em várias, todas nomeadas como 00_functions_something.R, em particular, se eu pretender criar um pacote com algumas delas, eu as separarei

00_explore.R

• um monte de pedaços de script em que estou testando coisas ou explorando meus dados
• É o único arquivo em que posso ficar bagunçado.

01_initialize.R

• Pré-preenchido com uma chamada para um initialize_general.Rscript mais geral da minha pasta de modelo que carrega os pacotes e dados que eu sempre uso e não me importo de ter no meu espaço de trabalho
• cargas 00_functions.R(pré- carregadas )
• carrega bibliotecas adicionais
• definir variáveis ​​globais

02_load data.R

• carrega csv/txt xlsx RDS, há uma linha comentada pré-preenchida para cada tipo de arquivo
• exibe quais arquivos foram criados na área de trabalho

03_pull data from DB.R

• Usa dbplyrpara buscar tabelas filtradas e agrupadas do banco de dados
• algumas linhas comentadas pré-preenchidas para configurar conexões e buscar.
• Mantenha as operações do lado do cliente no mínimo
• Nenhuma operação do lado do servidor fora deste script
• Exibe quais arquivos foram criados na área de trabalho
• Salva essas variáveis ​​para que possam ser recarregadas mais rapidamente

Uma vez feito isso, eu desligo um query_dbbooleano e os dados serão recarregados da RDSpróxima vez.

Pode acontecer que eu tenha que realimentar os dados para os bancos de dados. Nesse caso, criarei etapas adicionais.

04_Build.R

• Disputa de dados, toda a diversão dplyr/ tidyrmaterial vai para lá
• exibe quais arquivos foram criados na área de trabalho
• salve essas variáveis

Uma vez feito isso, eu desligo um buildbooleano e os dados serão recarregados da RDSpróxima vez.

05_Analyse.R

• Resuma, modelo ...
• relatório excele csvarquivos

95_build ppt.R

• modelo de relatório do powerpoint usando officer

96_prepare markdown.R

• setwd
• Carregar dados
• definir parâmetros de remarcação, se necessário
• render

97_prepare shiny.R

• setwd
• Carregar dados
• defina parâmetros brilhantes, se necessário
• runApp

98_Markdown report.Rmd

• Um modelo de relatório

99_Shiny report.Rmd

• Um modelo de aplicativo

Para escrever um relatório ou email preliminar rápido para um colega, acho que pode ser muito eficiente copiar e colar plotagens no MS Word ou em uma página de email ou wiki - geralmente é melhor uma captura de tela de bitmap (por exemplo, no mac, Apple -Shift- (Ctrl) -4). Eu acho que essa é uma técnica subestimada.

Para um relatório mais final, escrever funções R para regenerar facilmente todos os gráficos (como arquivos) é muito importante. Leva mais tempo para codificar isso.

Nas questões maiores do fluxo de trabalho, gosto da resposta de Hadley na enumeração dos arquivos de código / dados para o fluxo de limpeza e análise. Todos os meus projetos de análise de dados têm uma estrutura semelhante.

Vou adicionar minha voz para sweave. Para análises complicadas e de várias etapas, você pode usar um makefile para especificar as diferentes partes. Pode impedir a repetição de toda a análise se apenas uma parte tiver sido alterada.

Eu também faço o que Josh Reich faz, apenas faço isso criando meus pacotes R pessoais, pois me ajuda a estruturar meu código e dados, e também é muito fácil compartilhá-los com outras pessoas.

1. crie meu pacote
2. carga
3. limpar \ limpo
4. funções
5. Faz

criando meu pacote: devtools :: create ('package_name')

load and clean: eu crio scripts na subpasta / pasta de dados do meu pacote para carregar, limpar e armazenar os objetos de dados resultantes no pacote usando devtools :: use_data (object_name). Então eu compilo o pacote. A partir de agora, a biblioteca de chamada (package_name) disponibiliza esses dados (e eles não são carregados até que seja necessário).

funções: eu coloco as funções para minhas análises na subpasta R / do meu pacote e exporto apenas aquelas que precisam ser chamadas de fora (e não as funções auxiliares, que podem permanecer invisíveis).

do: eu crio um script que usa os dados e funções armazenados no meu pacote. (Se as análises precisarem ser feitas apenas uma vez, também posso inserir esse script na subpasta / pasta de dados, executá-lo e armazenar os resultados no pacote para torná-lo facilmente acessível.)