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:

?

1 2 3 4

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:

?

1 2 3 4 5 6 7 8

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

?

1 2 3 4 5 6

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:

?

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

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