Processamento e paralelo no R.

A computação paralela é uma forma de computação na qual muitos cálculos que são realizados em simultaneamente, aumentando assim a velocidade de execução de determinados códigos. Esse tipo de processamento opera no princípio de que grandes problemas muitas vezes podem ser divididos em partes menores, que são então resolvidos simultaneamente ("em paralelo"). O possível aumento de velocidade máxima de um único programa, como resultado de paralelização é conhecida como Lei de Amdahl.

No R podemos trabalhar com a computação em paralelo por meio de dois pacotes, a saber: foreach e doParallel.

Inicialmente é necessário instalar e carregar os pacotes de interesse:

?

1 2 3

#Carrega os pacotes necessários para realizar o paralelismo library(foreach) library(doParallel)

Cada núcleo existente na sua máquina (ou uma parte deles) pode ser utilizado para se dividir as tarefas e, consequentemente, os cálculos, para isso, precisamos saber quantos núcleos temos disponíveis:

?

1 2 3 4 5 6 7

#Checa quantos núcleos existem ncl<-detectCores() ncl   #Registra os clusters a serem utilizados cl <- makeCluster(ncl) registerDoParallel(cl)

Note que podemos registrar menos clusters do que temos disponíveis, caso você não deseje que sua máquina fique "travada" realizando somente as operações de cálculo exigidas. Para testar a velocidade que o processamento em paralelo trás para o nosso código vamos inicialmente gerar uma base de dados:

?

1 2 3 4 5 6 7 8 9

#Gera o número de observações n<-1000   #Variáveis geradas x<-rnorm(n,0,1) y<-rnorm(n,1+2*x,2)   #Dataframe com as variáveis geradas dados<-data.frame(x,y)

Em seguida, vamos realizar o Bootstrap usando a função for usual do R para computar o Erro-Padrão dos parâmetros do modelo de regressão na forma: $y=\alpha+\beta x +\epsilon$ O código é dado por:

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

#Inicia a contagem do tempo ptm <- proc.time()   #Cria o vetor para armazenar o parãmetro beta em cada iteração Bootstrap beta<-rep(0,5000)   #Faz o Bootstrap usando a função for for(i in 1:5000) {   #Gera a amostra Bootstrap   bdados<-dados[sample(nrow(dados),nrow(dados),replace=T),]   beta[i]<-unname(lm(y~x,bdados)$coef[2]) } mean(beta) sd(beta)   #Para de contar o tempo proc.time() - ptm

Os resultados para a minha máquina com 4 núcleos e utilizando for foi:

Agora podemos usar a função foreach sem paralelismo para comparar também:

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

#Inicia a contagem do tempo ptm <- proc.time()   #Cria o vetor para armazenar o parãmetro beta em cada iteração Bootstrap beta<-rep(0,5000)   #Faz o Bootstrap usando a função foreach boot_b <- foreach(i=1:5000, .combine=c) %do% {   #Gera a amostra Bootstrap   bdados<-dados[sample(nrow(dados),nrow(dados),replace=T),]   beta[i]<-unname(lm(y~x,bdados)$coef[2]) } mean(beta) sd(beta)   #Para de contar o tempo proc.time() - ptm

Os resultados foram mais demorados do que utilizando somente o for:

Finalmente, podemos considerar realizar essas tarefas em paralelo, distribuindo os cálculos entre os núcleos registrados:

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

#Inicia a contagem do tempo ptm <- proc.time()   #Cria o vetor para armazenar o parãmetro beta em cada iteração Bootstrap beta<-rep(0,5000)   #Faz o Bootstrap usando a função foreach boot_b <- foreach(i=1:5000, .combine=c) %dopar% {   #Gera a amostra Bootstrap   bdados<-dados[sample(nrow(dados),nrow(dados),replace=T),]   beta[i]<-unname(lm(y~x,bdados)$coef[2]) } mean(boot_b) sd(boot_b)   #Para de contar o tempo proc.time() - ptm   #Stop clusters stopCluster(cl)

Usando o paralelismo, o Bootstrap foi muito mais rápido:

Nota-se que o processamento em paralelo realmente é vantajoso, mas outras funções como a família apply, sapply, lapply, mapply, etc. também são muito boas quando deseja-se que o código rode o mais rapidamente possível.