In this course you will learn how to program in R and how to use R for effective data analysis. You will learn how to install and configure software necessary for a statistical programming environment and describe generic programming language concepts as they are implemented in a high-level statistical language. The course covers practical issues in statistical computing which includes programming in R, reading data into R, accessing R packages, writing R functions, debugging, profiling R code, and organizing and commenting R code. Topics in statistical data analysis will provide working examples.
R Profiler (part 2)
Loading...
Do curso por Johns Hopkins University
R Programming
13828 classificações
Na lição
Week 4: Simulation & Profiling
This week covers how to simulate data in R, which serves as the basis for doing simulation studies. We also cover the profiler in R which lets you collect detailed information on how your R functions are running and to identify bottlenecks that can be addressed. The profiler is a key tool in helping you optimize your programs. Finally, we cover the str function, which I personally believe is the most useful function in R.
Conheça os instrutores
Roger D. Peng, PhDAssociate Professor, Biostatistics
Bloomberg School of Public Health
Jeff Leek, PhDAssociate Professor, Biostatistics
Bloomberg School of Public Health
Brian Caffo, PhDProfessor, Biostatistics
Bloomberg School of Public Health
Este é o profiler do R
e ele possui uma função chamada "Rprof".
Esta função é usada para iniciar o profiler no R.
Uma observação: o R precisa ser compilado com suporte ao profiler
e, por isso, não é algo que funcionará em todos os casos.
No entanto, eu diria que em 99,9% dos casos ele funcionará.
O R somente será compilado sem suporte ao profiler
em circunstâncias muito especiais.
Dessa forma, há uma grande chance de que sua versão do R suporte o profiler.
Uma outra função útil é função "summaryRprof"
que recebe a saída do profiler e a resume
de forma que fique mais legível, uma vez
que os dados brutos de saída do profiler, em geral, não são muito úteis.
Portanto, a função "summaryRprof" é muito importante.
Vale a pena lembrar que você não deve usar a função "system.time"
e a função "Rprof" juntas.
Elas não foram feitas para trabalharem juntas ou serem usados ao mesmo tempo.
Portanto, você deve usar sempre uma ou outra mas não as duas juntas.
Assim, a função "Rprof" monitora
a pilha de execução em intervalos regulares.
Conforme a função esteja rodando,
ela vai e examina a pilha de execução,
quantas funções chamam outras funções e que chamam outras funções
e imprime isso.
Basicamente, o que ela faz é imprimir a pilha de execução de chamadas de funções
em intervalos bem rápidos, a cada 0.02 segundos,
e imprime a pilha de execução.
A primeira coisa que você perceberá é que, se sua função levar menos
de 0,02 segundos para rodar, então o profiler do R será inútil
porque, devido a isso, ela nunca amostrará a pilha de execução.
Ou seja, se o seu programa roda muito rapidamente, o profiler não é útil.
Claro que, se o seu programa roda muito rápido,
você nem deve pensar em executar o profiler nesse caso.
Então, geralmente isso não é um problema.
Mas você realmente precisa usar o profiler em situações que seu código
leve muito mais tempo, pelo menos na ordem de segundos.
Aqui segue um exemplo da saída de dados brutos que vêm do profiler.
Aqui segue um exemplo da saída de dados brutos que vêm do profiler.
Geralmente você nunca usará essa saída
mas, achei que seria interessante ver o que acontece.
Você pode ver que estou chamando a função "lm",
com a saída de uma variável e feita de só um preditor.
O que acontece aqui, como você pode ver,
é que cada linha da saída é a pilha de execução das chamadas das funções.
Veja a extremidade direita, ela é meio que o topo
e a extrema esquerda é similar à base, por assim dizer.
similar à base, por assim dizer.
Assim, à extrema direita, você pode ver
que "lm" foi chamada, "lm" chamou "eval" e "eval" chamou "eval".
Então, estou indo da direita para esquerda.
E "eval" chamou "model.frame", que chamou "model.frame.default"
que chamou "eval" novamente, "eval" e então "list".
Então, todas essas funções chamam umas às outras.
Então você consegue ver que as chamadas de função vão muito além.
Conforme você segue adiante na avaliação, consegue ver
que as chamadas às funções que mudam, então bem na baseque as chamadas às funções que mudam, então bem na base
da pilha você pode ver que "lm" chamou "lm.fit"
e, se você não está familiarizado com a função "lm", "lm.fit" é realmente
o burro de carga dessa função, que realiza todo o tipo de cálculo.
Dessa forma, você não suspeitaria
se gastasse uma boa quantidade de tempo na função "lm.fit"
Esse tipo de saída bruta de dados não é
exatamente fácil de se ler, então usamos a função "summaryRprof"
que identa a saída do Rprof
e calcula quanto tempo foi gasto em cada função.
Assim, a ideia é que uma vez que você veja a pilha de execução, você sabe que,
cada linha da saída é a pilha de execução a cada 0,02 segundos.cada linha da saída é a pilha de execução a cada 0,02 segundos.
a pilha de execução das chamdas das funções a cada 0,02 segundos.
Que é a frequência de amostragem da função.
Portanto, dado isso você pode calcular quantos segundos são
gastos em cada uma das funções, porque, se ela aparece na pilha
de execução, então você deve estar gastando algum tempo nela.
Existem então dois métodos para normalizar
os dados que você obtém do profiler do R.
Um é chamado "by.total", o qual divide o tempo gasto
em cada função pelo tempo total de execução
e "by.self", que faz a mesma coisa, mas primeiro
subtrai o tempo gasto em funções acima na chamada à pilha.
Então, é importante entender os dois
conceitos diferentes aqui "by.total" e "by.self".
A idea fundamental é que, em "by.total", essa normalização
pela quantidade total de tempo gasto em uma função lhe fornece basicamente
quantas vezes a função foi chamada
quantas vezes a função foi chamada na saída na tela.
Por exemplo, 100% do tempo é gasto na função de mais alto nível.
A função que você chama, digamos "lm", você gasta
100% do seu tempo nessa função, porque é a função de mais alto nível.
Porém, a verdade é que geralmente
as funções de alto nível não fazem nada
muito importante, tudo o que fazem é
chamar funções auxiliares que realizam o trabalho de verdade, OK?
Portanto, provalvemente, se sua função está gastando
muito tempo fazendo algo,
na verdade ela está gastando muito tempo nessas funções auxiliares que estão
sendo chamadas pela de alto nível para realizar todo o trabalho.
Dessa forma, geralmente não é muito interessante saber quanto tempo é gasto nessas
funções de alto nível, porque não é onde
o verdadeiro trabalho ocorre.
Agora, você quer saber quanto tempo é gasto
na função de alto nível mas subtraindo todas
as funções de nível mais baixo que são chamadas, certo?
Acontece que se gasta muito tempo
na função de alto nível mesmo após retirarmos todas as funções
de mais baixo nível mas ainda nos resta algo interessante.
Na maior parte do tempo você perceberá que, quando você exclui todas as funções de nível
mais baixo que são chamadas, há pouquíssimo tempo
mais baixo que são chamadas, há pouquíssimo tempo gasto na função superior.
E uma vez que todo o trabalho e computação está sendo feita
nas funções de baixo nível,
nas funções de baixo nível, é lá que você deve concentrar toda sua atenção.
Então, eu creio que a função "by.self" é o formato
mais interessante a ser usado, porque informa quanto tempo
está sendo gasto em dada função após excluir todo tempo
gasto em funções de baixo nível que foram chamadas.
Portanto, na minha opinião, ele fornece um quadro mais
preciso de quais funções estão realmente
tomando a maior quantia do tempo e quais funções
que você deve procurar otimizar depois.
Segue um exemplo de uma saída pelo formato de "by.total". Você pode ver bem claramente,
na parte superior, que 100% do tempo é gasto na função "lm".
O tempo total de execução foi de 7.41 segundos
e todo o tempo foi gasto em "lm".
Claro, porque "lm" é a função de maior nível.
Mas você pode ver que a segunda colocada foi a função "lm.fit".
Mas você pode ver que a segunda colocada foi a função "lm.fit".
Eu mencionei que "lm.fit" é onde boa parte da computação acontece
e ali foram 3.5 segundos,
portanto, metade do tempo foi nessa função.
Agora, fica claro que diversas
funções como "model.frame", "model.frame.default" e "eval",
todas essas funções não envolvem muita
computação mas há uma quantia razoável de tempo
gasto nessas funções, então é, de certa forma, bem interessante.
Eu acho que uma saída mais útil é a "by.self",
que subtrai todas as chamadas à funções de baixo nível
e calcula a quantidade de
e calcula a quantidade de tempo que é realmente gasto nesta função.
Aqui você pode ver que "lm.fit" é
a vencedora, porque é lá que de fato acontecem todos os cálculos.
Em particular, "lm.fit" chama uma rotina de 4 etapas para inverter uma matriz.
Assim, é lá que geralmente ocorre a computação da maioria dos problemas
de regressão em larga escala. A próxima função que aparentemente gasta
bastante tempo, ou 11% do tempo,
é a função "as.list", pelo método "as.list.data.frame".
Não é imediatamente claro por que tempo tempo está sendo gasto nesta função
gasto nesta função,
mas talvez seja algo que você queira investigar.
Porque, talvez não seja muito importante para os cálculos principais.
Então você pode acompanhar a lista,
ver quanto tempo está sendo gasto em diversas funções
e então, ver que muitas dessas funções não pertencem diretamente
aos cálculos principais mas, na verdade,
pertencem à formatação dos dados e coisas do tipo.
A parte final da saída do summaryRprof é
somente o intervalo amostral, então você pode ver
que foi o intervalo de tempo que a amostragem ocorreuque foi o intervalo de tempo que a amostragem ocorreu
para a impressão da pilha de execução.
E você pode ver que é 0.02 segundos.
E o tempo de amostragem, que é somente
a quantidade total de tempo que a expressão levou para rodar.
Acredito que isso equivale
tempo decorrido na função "system.time".
Este foi um passeio rápido pelo profiler do R.
Uma ferramenta muito útil para realizar análise de performance de um código R,
que fornece um feedback útil e que normalmente aponta funções
que você nem suspeitava que seriam gargalos
e por não serem exatamente o centro da
computação de fato, na qual você está trabalhando.
Então o profiler pode ser muito útil
por apontar esses tipos de situações
e algumas vezes encontrando coisas que você não esperava.
A função "summaryRprof" resume a saída da "Rprof"
e lhe fornece o percentual de tempo gasto em cada função.
E a normalização "by.self" é um tipo
mais útil para destacar gargalos no seu código.
Uma das implicações de usar
o profiler é uma vantagem por dividir seu código em funções.
Então, ao invés de se ter uma gigantesca função,
é muito prático dividir o código em partes lógicas de diferentes funções.
E então o profiler pode usar essa informação
para dizer onde o tempo está sendo gasto.
Portanto, lembre-se que o profiler imprime a pilha de execução
e, se você dividir seu código em diversas funções menores,
os nomes das funções que você deu servirão como identificadores
na pilha de execução para dizer onde
o código está levando a maior parte do tempo.
Então, essa é mais uma estratégia
que pode ser bem útil quando você estiver traçando o perfil do seu código R.
Um último detalhe é que, se seu código R, ou qualquer código R,
chama um código C ou Fortran, esse código em C ou Fortran é como uma caixa-preta.
Ele não é analisado pelo profiler.
Você não verá qualquer informação sobre esse código.
Tudo o que saberá é que algum tempo
é gasto lá, mas você não obterá nenhum detalhe sobre isso.
No geral, creio que o profiler é muito útil
e eu lhe aconselho a usá-lo
ao invés de apenas tentar adivinhar onde deve melhorar o código,
já que o profiler pode ser usado para
coletar dados sobre onde o tempo está sendo gasto.
Tradução: Matheus de Lima Barbosa | Revisão: Caio Miyashiro e Carlos Lage.
Explore nosso catálogo
Registre-se gratuitamente e obtenha recomendações, atualizações e ofertas personalizadas.
O Coursera proporciona acesso universal à melhor educação do mundo fazendo parcerias com as melhores universidades e organizações para oferecer cursos on-line.
© 2019 Coursera Inc. Todos os direitos reservados.
