Amazon Web Service - AWS. Usando RStudio e CUDA na Amazon.

Um dos principais desafios do Análise de Dados atualmente é realizar operações rapidamente em muito conjunto de dados. Nesse sentido, uma vez que o custo de equipamentos para computação em paralelo (Compute Unified Device Architecture) são muito caros para os pesquisadores.

Uma solução é pegar "emprestado" alguns minutos ou horas de servidores que tenham os hardwares necessários. Para isso podemos usar o Amazon Web Service. Nesse post vou mostrar como configurar um servidor Amazon com GPU (Graphics processing unit).

Assumo aqui que você já tem uma conta na Amazon e na Amazon Web Service com cartão de crédito registrado.

O primeiro passo é entrar no Amazon Web Service e fazer o login. Em seguida visitar o AWS Management Console e escolher a opção Compute - EC2:

Escolha agora a opção Launch Instance:

Escolha AWS Market Place e na caixa de Busca digite RStudio:

Nesse exemplo como queremos um servidor com GPU escolhemos RStudio Server with Tensorflow-GPU for AWS:

Aparecerá uma tela com os valores. Se estiver de acordo, clique em Continue:

Em seguida precisamos escolher o tipo da instância. Quanto mais potente for o servidor e seus hardwares mais caro será o minuto de processamento. Os servidores que possuem GPU estão habilitados na página:

Nesse exemplo eu escolhi GPU compute: p2.xlarge e após clicar em Next: Configure Instance Details você deve manter tudo como está, exceto a opção Auto-assign Public IP que deve ser marcada como Enable:

Após essa alteração clique em Review and Launch:

E após revisar, se tudo estiver de acordo clique em Launch:

Por simplicidade vamos proceder sem chave:

Agora seu servidor está sendo inciado. Você deve então clicar no nome da instância (guarde esse nome pois será a senha do RStudio Server):

Quando ele estiver pronto, deve aparecer um sinal verde:

Para acessar o servidor, copie o endereço de IP na parte inferior nomeado como IPv4 Public IP e digite no navegador o IP seguido da porta 8787, algo como: XX.XXX.XX.XX:8787. Copie também o Instance ID na parte inferior pois será a senha do servidor AWS. Caso tudo tenha dado certo a tela de login surgirá no seu navegador:

Utilize como login: rstudio-user e a senha deve ser o Instance ID. Clique em Login e Pronto!! Pode começar a usar...

Agora, quando terminar o uso é preciso terminar a instância para evitar ser cobrado, para isso viste https://console.aws.amazon.com/ec2/. Lá deverá constar todas as suas instâncias, escolha a instância que você quer terminar e clique com o botão direito escolhendo a opção Instace State e Terminate:

Confirme que você realmente deseja terminar a instância:

.

A partir de agora você não será mais cobrado pelo uso do servidor. Caso deseje mais detalhes sobre o servidor visite: https://tensorflow.rstudio.com/tools/cloud_server_gpu.html#amazon-ec2

Usando a função DEoptim em paralelo.

Um dos pacotes mais interessantes para realizar otimização é o pacote DEoptim. Essa abordagem permite a otimização de funções dos mais diversos tipos de uma maneira fácil.

Entretanto, por usar Otimização Evolucionária o processo de otimização pode ser lento, caso utilize-se muitas populações, iterações ou níveis tolerância extremos.

Aqui mostrarei como usar a opção parallelType da função DEoptim para que esse processo seja acelerado por meio da programação em paralelo.

Considere a seguinte função com múltiplos máximos e mínimos locais:

f<-function(x,y){
  res<-(268/((3*x+18)^2+(3*y+7)^2+(18+7)))-(2*(268)/((3*x-21)^2+(3*y+21)^2+(21+21)))-(3*(268)/((3*x+18)^2+(3*y-21)^2+(18+21)))+(4*(268)/((3*x-21)^2+(3*y-7)^2+(21+7))) 
  return(res)
}

Podemos fazer o gráfico dessa função através do seguinte bloco de comandos:

#Chama a biblioteca
library(plot3D)
#Cria a grade de valores na função
z<-f(M[,"x"], M[,"y"])
#Faz o gráfico
persp3D(z = z, x = M[,"x"], y = M[,"y"],
        expand = 0.3, main = "Função complicada", facets = FALSE, scale = FALSE,
        clab = "Valor da função",zlab="Valor", colkey = list(side = 1, length = 0.5))

O próximo passo para realizar a otimização é escrever a função no formato adequado para o uso do método DEoptim. Para isso, basta trocar o argumento da função que ao invés de serem dois parâmetros, será agora um vetor contendo esses dois argumentos, em outras palavras:

fEval<-function(parms){
  x<-parms[1]
  y<-parms[2]
  res<-(268/((3*x+18)^2+(3*y+7)^2+(18+7)))-(2*(268)/((3*x-21)^2+(3*y+21)^2+(21+21)))-(3*(268)/((3*x+18)^2+(3*y-21)^2+(18+21)))+(4*(268)/((3*x-21)^2+(3*y-7)^2+(21+7))) 
  return(res)
}

Note que só as três primeiras linhas foram alteradas. A seguir, precisamos configurar os nossos clusters para que a função possa ser otimizada em paralelo, a função busca pelo menor valor da função:

#Chama o pacote DEoptim e doSNOW
library(DEoptim)
library(doSNOW)
#Guarda o número de clusters disponíveis
numSlaves<- detectCores()
#Cria os clusters
cl <− makeCluster(numSlaves) 
#Passa todas as bibliotecas que são usadas para o cálculo da função
#clusterEvalQ(cl , library(pracma, ... ))
#Passa todos os objetos necessários para o cômputo da função
#clusterExport(cl , ... ) 
#Registra os clusters
registerDoSNOW (cl)
#Realiza a otimização
outDEoptim <− DEoptim (fEval, c(-15,-15), c(15,15), DEoptim.control(list(trace=FALSE, NP=50, itermax=50, parallelType = 2)))
#Fecha os clusters
stopCluster(cl)
#Guarda os melhores resultados.
fim <- outDEoptim $ optim $ bestmem
fim

Alguns comentários são importantes: as linhas 8 e 10 são utilizadas para se passar bibliotecas e objetos do R que são utilizados no cômputo da função que deve ser otimizada. Nesse caso, como não usamos nenhum pacote especial para o cômputo da função e nem bibliotecas esses comandos estão comentados. Caso deseje-se passar esses valores, basta atribuí-los na forma de lista em cada comando. Na função DEoptim o primeiro argumento é a função a ser minimizada, seguido pelos limites inferiores e superiores para os argumentos. O último argumento é uma lista que controla as condições da função de otimização: NP é o número de populações a serem geradas no algoritmo de Otimização Evolucionária, itermax é o número total de iterações e parallelType = 2 define a forma de paralelismo a ser considerada. Observe ainda que se o valor de NP e/ou itermax e o paralelismo não for adotado, esse processo pode ser muito lento computacionalmente, daí a vantagem de se utilizar o processamento em paralelo que pode reduzir esse tempo computacional significativamente. Mote ainda que o comando trace=FALSE é para suprimir os resultados em cada iteração, e caso deseje-se maximizar a função ao invés de minimizar, basta trabalhar com o valor do negativo da função, ou ainda com seu recíproco.

Utilizando RStudio na nuvem com Amazon AMI.

Frequentemente, temos códigos que rodam por horas ou até dias... Impossibilitando o computador para a realização de outras tarefas. Uma solução interessante é "alugar" máquinas que façam essas análises para você.

Hoje está cada vez mais fácil trabalhar com computação em nuvem. Vou mostrar nesse post como utilizar o serviço da Amazon para computação em nuvem com RStudio.

1) O primeiro passo é criar uma conta AWS (Amazon Web Services).

2) Em seguida, vá ao site RStudio Server Amazon Machine Image (AMI). Você pode escolher alguma das regiões disponíveis, para as quais o RStudio já está instalado, como por exemplo, São Paulo:

Nessa etapa você já deve ter sua conta AWS (Amazon Web Services), após preencher com o nome de usário e senha a seguinte tela surge:

Note que há uma lista de possíveis máquinas e configurações disponíveis. Cada máquina possui um valor diferente para o aluguel do serviço. No caso de programação em paralelo deve-se atentar ao número de núcleos (cores) disponíveis e no caso de grandes bases de dados, também na memória RAM disponível.

3) Após escolher a máquina clique no botão Next: Configure Instance Details. Pode aceitar as configurações default e seguir para o próximo passo clicando em Next: Add Storage.

4) Também, nessa etapa (caso não necessite de nenhuma das opções apresentadas) pode seguir para o passo 5) clicando em Next: Tag Instance.

5) Essa é mais uma etapa optativa, não é necessário preencher os campos Key e Value.

6) Essa é mais uma etapa optativa, não é necessário preencher os campos Key e Value. Clique em Next: Configure Security Group.

7) Nessa etapa você deve escolher Type igual a HTTP e nos campos Security group name e Description pode preencher com o nome RStudio:

8) A última etapa para a criação do RStudio Server é clicar no botão Review and Launch. A Amazon irá apresentar as configurações escolhidas e então basta clicar em Launch para criar a instância. Obs: Caso surja uma janela com os dizeres Select an existing key pair or create a new key pair escolha a opção Proceed without a key pair.

Abrindo o RStudio Server na nuvem.

Se as etapas anteriores foram executadas corretamente uma tela como a apresentada abaixo deve surgir:

1)Para abrir o RStudio Server, clique no nome da instância destacada na imagem anterior no retângulo vermelho.

2)Na tela que surgir, procure pelo endereço explicitado em Public DNS. O endereço estará no canto inferior direito da tela. Ao copiar e colar nesse endereço no navegador a seguinte tela aparecerá:

3) Escolha como Username: rstudio e Password: rstudio e então clique em Sign In. Após essas etapas surge:

4) Você deve alterar a senha, para isso, na linha 18, troque o nome "mypassword" pelo nova senha desejada e então execute todo o programa. Pronto! A senha foi atualizada. A partir de agora todo o login deverá ser feito com a nova senha escolhida.

Importando e exportando objetos no RStudio Server.

Caso você tenha alguma base de dados que deseja trabalhar, basta fazer o Upload para o servidor. Basta clicar na opção Upload da aba Files:

Como exercício, fiz o Upload do arquivo german.csv (a descrição da base também está disponível):

Podemos criar alguns novos objetos:

#Importa a base de dados
german.df<-read.csv("german.csv")

#Gera uma variável N(0,1)
x<-rnorm(100,0,1)

Da mesma maneira que podemos fazer o Upload de dados podemos também fazer Download. Por exemplo, se fizermos um histograma:

#Cria o histograma
hist(x)

Podemos salvá-lo em nossa máquina, basta clicar na opção Export:

Em seguida, salve o gráfico na nuvem:

Por fim, escolhemos os objetos que desejamos exportar e clicamos na opção Export:

. Escolha a opção Download:

Interface entre o RStudio Server da Amazon e Dropbox.

Por facilidade, podemos fazer o Download e o Upload de objetos entre o RStudio Server da Amazon e Dropbox. Para isso, além de uma conta no Dropbox, instalar o pacote rDrop. Os passos são: 1) Instale o pacote devtools no RStudio Server da Amazon. 2) Instale o pacote rDrop:

#Habilita o pacote devtools
library(devtools)

#Instala o pacote rDrop
install_github("duncantl/ROAuth")
install_github("karthik/rDrop")

3) Autorize o uso do RStudio Server da Amazon na sua conta do Dropbox. Para isso você precisa criar um App Dropbox developer site. Clique em Create App:

4) Escolha a opção Dropbox Api app:

5) Uma vez que o App foi criado, certifique-se de guardar sua App key e App secret em algum lugar seguro.

#Habilita o pacote rDrop
library(rDrop)

#Insere a App key necessária para a utilização do dropbox
dropbox_credentials <- dropbox_auth("App key", "App secret")

6) Podemos importar dados do Dropbox e exportar dados, basta usar os comandos:

#Salva arquivos no dropbox
?dropbox_save

#Importa arquivos do dropbox
?dropbox_get

Por fim, por se tratar de um serviço PAGO após terminar o uso do RStudio Server Amazon você precisa encerrar a instância, ou então vai continuar pagando pelo serviço. Para isso, basta ir no site AWS onde o servidor foi configurado e na opção Instances parar a instância:

Também é possível encerrar a instância por meio do código:

#Enccerra a instância do RStudio Server na Amazon:
system("sudo shutdown -h now", wait = FALSE)

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:

#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:

#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:

#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:

#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:

#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:

#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.