Universidade de Bras lia Mestrado em Estat stica T ecnicas Computacionais em Estat stica - Projeto 3

Thiago VedoVatto 30 de junho de 2013

Resumo Neste trabalho implementa-se v arios m etodos de otimiza ca o n ao-linear. Esses m etodos ser ao testados em um conjunto padr ao de fun co es. Ser a observado que cada m etodo implementado apresenta um desempenho melhor ou pior em cada tipo de fun ca o.

Introdu c ao

Podemos denir otimiza c ao como sendo o conjunto dos m etodos capazes de determinar as melhores congura c oes poss veis para a constru ca o ou o funcionamento de sistemas de interesse do ser humano. Para os efeitos desse trabalho denem-se: Fun c ao Objetivo Representa o ndice de desempenho do sistema, cujo valor, por conven c ao, queremos minimizar para atingirmos o desempenho otimo; a solu Solu c ao Otima E c ao que minimiza o valor da fun c ao objetivo; Restri c oes S ao as condi c oes de igualdade e/ou desigualdade a que est a sujeito o resultado da otimiza c ao. Regi ao Fact vel Conjunto de pontos do espa co real que satisfaz todas as restri c oes; Ponto Fact vel Ponto que pertence a regi ao fact vel; Os m etodos de otimiza c ao s ao comparados de acordo com os crit erios:
N umero de avalia c oes da fun c ao-objetivo e das fun c oes de restri c ao; Proximidade da solu c ao encontrada da solu c ao otima.

Para garantir que todos os m etodos ser ao testados de maneira justa ser ao escolhidos 1000 pontos em uma regi ao de busca inicial predeterminada para cada fun c ao de teste e todos os m etodos ser ao iniciados a partir dos mesmos pontos. A regi ao de busca que adotaremos para cada fun c ao e descrita em anexo, onde poder ao ser vistas todas as fun c oes, suas implementa c oes e pontos de m nimos. No anexo tamb em ser a encontrada o c odigo da fun c ao de teste geral dos otimizadores. Para que os resultados sejam apresentados de maneira a facilitar a compara c ao dos resultados adota-se as seguintes constantes de modo geral: > > > > > > GERALquantidade.pontos = 1000; GERALerro = 0.001; GERALmaxiteracao = 1000; GERALepsilon.convergencia = 0.1; GERALcritCAG = 0.0001; GERALcritCEFO = 0.0001; Nesse relat orio ser ao testados os seguintes m etodos de otimiza c ao:
M etodo do Gradiente;

 M etodo de Newton; M etodo de Newton Modicado; M etodo Quasi-Newton (com corre c ao de posto, DFP, BFGS e h brido); M etodo Elipsoidal (simples e com deepcut).

As implementa c oes de todos os m etodos podem ser encontradas em anexo. As fun c oes de teste ser ao variadas sendo compostas de fun c oes simples e de fun c oes de alto n vel de diculdade:
Fun c ao Esfera; Fun c ao Beale; Fun c ao Rosenbrock; Fun c ao Rastringin; Fun c ao Hager; Fun c ao Eason; Fun c ao Ackley; Fun c ao Bukin; Fun c ao Three-hump Camel; Fun c ao Schaer2; Fun c ao Styblinskitang.

As deni c oes de todas as fun c oes bem como suas implementa c oes e gr acos podem ser encontrados no anexo.

2
2.1

Resultados
Fun c ao Esfera

A fun c ao esfera e uma das fun c oes mais simples poss veis de se otimizar. Nesse teste adotou-se a regi ao de busca na qual |xi | < 10. O sum ario do teste para duas vari aveis e visto a seguir. Note que todos os m etodos s ao extremamente ecientes nesse problema. > testaotimizadores(funcao = esfera, + vetor.busca.minimo = c(-10,-10), + vetor.busca.maximo = c(10,10), + quantidade.pontos = GERALquantidade.pontos, + ponto.otimo = c(0,0), + erro = GERALerro, + funcao.max = 200, + maxiteracao = GERALmaxiteracao, + epsilon.convergencia = GERALepsilon.convergencia, + critCAG = GERALcritCAG, + critCEFO = GERALcritCEFO) $acertos.gradiente [1] 1000 $media.itera c~ oes.gradiente [1] 2.765 $acertos.newton 2

[1] 1000 $media.itera c~ oes.newton [1] 2 $acertos.newtonmod [1] 1000 $media.itera c~ oes.newtonmod [1] 2.504 $acertos.quasinewton.cp [1] 1000 $media.itera c~ oes.quasinewton.cp [1] 5.975 $acertos.quasinewton.dfp [1] 1000 $media.itera c~ oes.quasinewton.dfp [1] 5.975 $acertos.quasinewton.bfgs [1] 1000 $media.itera c~ oes.quasinewton.bfgs [1] 5.98 $acertos.quasinewton.hb [1] 1000 $media.itera c~ oes.quasinewton.hb [1] 5.98 $acertos.elipsoidal [1] 582 $media.itera c~ oes.elipsoidal [1] 25.00344 $acertos.elipsoidal.deepcut [1] 398 $media.itera c~ oes.elipsoidal.deepcut [1] 28.3794 O sum ario do teste para dez vari aveis e dado a seguir, note que os m etodos implementados continuam sendo muito ecientes. > testaotimizadores(funcao = esfera, + vetor.busca.minimo = rep(-10,10), + vetor.busca.maximo = rep(10,10), + quantidade.pontos = GERALquantidade.pontos, + ponto.otimo = rep(0,10), + erro = GERALerro, + funcao.max = 1000, + maxiteracao = GERALmaxiteracao, + epsilon.convergencia = GERALepsilon.convergencia, 3

+ + $acertos.gradiente [1] 1000

critCAG = GERALcritCAG, critCEFO = GERALcritCEFO)

$media.itera c~ oes.gradiente [1] 2.755 $acertos.newton [1] 1000 $media.itera c~ oes.newton [1] 2 $acertos.newtonmod [1] 1000 $media.itera c~ oes.newtonmod [1] 2.502 $acertos.quasinewton.cp [1] 1000 $media.itera c~ oes.quasinewton.cp [1] 5.965 $acertos.quasinewton.dfp [1] 1000 $media.itera c~ oes.quasinewton.dfp [1] 5.965 $acertos.quasinewton.bfgs [1] 1000 $media.itera c~ oes.quasinewton.bfgs [1] 5.968 $acertos.quasinewton.hb [1] 1000 $media.itera c~ oes.quasinewton.hb [1] 5.968 $acertos.elipsoidal [1] 935 $media.itera c~ oes.elipsoidal [1] 140.7561 $acertos.elipsoidal.deepcut [1] 928 $media.itera c~ oes.elipsoidal.deepcut [1] 152.8524 Por m o sum ario do teste para vinte vari aveis e dado por:

> testaotimizadores(funcao = esfera, + vetor.busca.minimo = rep(-10,20), + vetor.busca.maximo = rep(10,20), + quantidade.pontos = GERALquantidade.pontos, + ponto.otimo = rep(0,20), + erro = GERALerro, + funcao.max = 2000, + maxiteracao = GERALmaxiteracao, + epsilon.convergencia = GERALepsilon.convergencia, + critCAG = GERALcritCAG, + critCEFO = GERALcritCEFO) $acertos.gradiente [1] 1000 $media.itera c~ oes.gradiente [1] 2.793 $acertos.newton [1] 1000 $media.itera c~ oes.newton [1] 2 $acertos.newtonmod [1] 1000 $media.itera c~ oes.newtonmod [1] 2.479 $acertos.quasinewton.cp [1] 1000 $media.itera c~ oes.quasinewton.cp [1] 5.902 $acertos.quasinewton.dfp [1] 1000 $media.itera c~ oes.quasinewton.dfp [1] 5.899 $acertos.quasinewton.bfgs [1] 1000 $media.itera c~ oes.quasinewton.bfgs [1] 5.916 $acertos.quasinewton.hb [1] 1000 $media.itera c~ oes.quasinewton.hb [1] 5.916 $acertos.elipsoidal [1] 913 $media.itera c~ oes.elipsoidal [1] 150.4304 5

$acertos.elipsoidal.deepcut [1] 870 $media.itera c~ oes.elipsoidal.deepcut [1] 305.5368

2.2

Fun c ao Beale

A fun c ao Beale e denida apenas para duas vari aveis. O sum ario do teste e dado na sequencia. Note que para essa fun c ao os m etodos quasi-newton e elipsoidal levam ligeira vantagem sobre os demais. > testaotimizadores(funcao = beale, + vetor.busca.minimo = c(-4.5,-4.5), + vetor.busca.maximo = c(4.5,4.5), + quantidade.pontos = GERALquantidade.pontos, + ponto.otimo = c(3,0.5), + erro = GERALerro, + funcao.max = 150000, + maxiteracao = GERALmaxiteracao, + epsilon.convergencia = GERALepsilon.convergencia, + critCAG = GERALcritCAG, + critCEFO = GERALcritCEFO) $acertos.gradiente [1] 130 $media.itera c~ oes.gradiente [1] 15.19231 $acertos.newton [1] 70 $media.itera c~ oes.newton [1] 8.014286 $acertos.newtonmod [1] 117 $media.itera c~ oes.newtonmod [1] 7.307692 $acertos.quasinewton.cp [1] 367 $media.itera c~ oes.quasinewton.cp [1] 12.51499 $acertos.quasinewton.dfp [1] 312 $media.itera c~ oes.quasinewton.dfp [1] 10.89744 $acertos.quasinewton.bfgs [1] 70 $media.itera c~ oes.quasinewton.bfgs [1] 8.671429 6

$acertos.quasinewton.hb [1] 79 $media.itera c~ oes.quasinewton.hb [1] 10.07595 $acertos.elipsoidal [1] 400 $media.itera c~ oes.elipsoidal [1] 25.945 $acertos.elipsoidal.deepcut [1] 172 $media.itera c~ oes.elipsoidal.deepcut [1] 121.9186

2.3

Fun c ao Rosenbrock

Nesse teste adotou-se a regi ao de busca na qual |xi | < 2.4. O sum ario do teste para duas vari aveis e dado a seguir. Aqui o destaque est a para os m etodos de Newton e Newton-modicado. > testaotimizadores(funcao = rosenbrock, + vetor.busca.minimo = c(-2.4,-2.4), + vetor.busca.maximo = c(2.4,2.4), + quantidade.pontos = GERALquantidade.pontos, + ponto.otimo = c(1,1), + erro = GERALerro, + funcao.max = 6000, + maxiteracao = GERALmaxiteracao, + epsilon.convergencia = GERALepsilon.convergencia, + critCAG = GERALcritCAG, + critCEFO = GERALcritCEFO) $acertos.gradiente [1] 499 $media.itera c~ oes.gradiente [1] 45.41483 $acertos.newton [1] 746 $media.itera c~ oes.newton [1] 4.883378 $acertos.newtonmod [1] 988 $media.itera c~ oes.newtonmod [1] 10.80668 $acertos.quasinewton.cp [1] 267 $media.itera c~ oes.quasinewton.cp [1] 19.52809 7

$acertos.quasinewton.dfp [1] 473 $media.itera c~ oes.quasinewton.dfp [1] 25.29175 $acertos.quasinewton.bfgs [1] 75 $media.itera c~ oes.quasinewton.bfgs [1] 7.093333 $acertos.quasinewton.hb [1] 80 $media.itera c~ oes.quasinewton.hb [1] 8.525 $acertos.elipsoidal [1] 316 $media.itera c~ oes.elipsoidal [1] 31.48101 $acertos.elipsoidal.deepcut [1] 456 $media.itera c~ oes.elipsoidal.deepcut [1] 218.0461

2.4

Fun c ao Rastringin

A fun c ao Rastringin e reconhecida como um desao aos m etodos de otimiza c ao. Nesse teste adotou-se a regi ao de busca na qual |xi | < 5.12. Note que no sum ario ca claro que a eci encia dos m etodos cai radicalmente nessa situa c ao. > testaotimizadores(funcao = rastringin, + vetor.busca.minimo = c(-5.12,-5.12), + vetor.busca.maximo = c(5.12,5.12), + quantidade.pontos = GERALquantidade.pontos, + ponto.otimo = c(0,0), + erro = GERALerro, + funcao.max = 80, + maxiteracao = GERALmaxiteracao, + epsilon.convergencia = GERALepsilon.convergencia, + critCAG = GERALcritCAG, + critCEFO = GERALcritCEFO) $acertos.gradiente [1] 41 $media.itera c~ oes.gradiente [1] 19.09756 $acertos.newton [1] 22 $media.itera c~ oes.newton 8

[1] 4.454545 $acertos.newtonmod [1] 22 $media.itera c~ oes.newtonmod [1] 8.363636 $acertos.quasinewton.cp [1] 29 $media.itera c~ oes.quasinewton.cp [1] 26.03448 $acertos.quasinewton.dfp [1] 21 $media.itera c~ oes.quasinewton.dfp [1] 9.571429 $acertos.quasinewton.bfgs [1] 22 $media.itera c~ oes.quasinewton.bfgs [1] 7.909091 $acertos.quasinewton.hb [1] 26 $media.itera c~ oes.quasinewton.hb [1] 9.846154 $acertos.elipsoidal [1] 9 $media.itera c~ oes.elipsoidal [1] 15.22222 $acertos.elipsoidal.deepcut [1] 7 $media.itera c~ oes.elipsoidal.deepcut [1] 2.428571 Analisando-se agora o caso da fun ca o Rastringin com quatro vari aveis nota-se que os m etodos implementados s ao totalmente inecientes nesse caso. > testaotimizadores(funcao = rastringin, + vetor.busca.minimo = rep(-5.12,4), + vetor.busca.maximo = rep(5.12,4), + quantidade.pontos = GERALquantidade.pontos, + ponto.otimo = rep(0,4), + erro = GERALerro, + funcao.max = 800, + maxiteracao = GERALmaxiteracao, + epsilon.convergencia = GERALepsilon.convergencia, + critCAG = GERALcritCAG, + critCEFO = GERALcritCEFO)

$acertos.gradiente [1] 0 $media.itera c~ oes.gradiente [1] 0 $acertos.newton [1] 0 $media.itera c~ oes.newton [1] 0 $acertos.newtonmod [1] 0 $media.itera c~ oes.newtonmod [1] 0 $acertos.quasinewton.cp [1] 0 $media.itera c~ oes.quasinewton.cp [1] 0 $acertos.quasinewton.dfp [1] 0 $media.itera c~ oes.quasinewton.dfp [1] 0 $acertos.quasinewton.bfgs [1] 0 $media.itera c~ oes.quasinewton.bfgs [1] 0 $acertos.quasinewton.hb [1] 0 $media.itera c~ oes.quasinewton.hb [1] 0 $acertos.elipsoidal [1] 0 $media.itera c~ oes.elipsoidal [1] 0 $acertos.elipsoidal.deepcut [1] 0 $media.itera c~ oes.elipsoidal.deepcut [1] 0

2.5

Fun c ao Hager

Nesse teste adotou-se a regi ao de busca na qual |xi | < 10. O sum ario do teste para duas vari aveis e dado por. Esta tamb em e uma fun c ao de dif cil otimiza c ao. Para este sum ario consideramos o epsilon para a

10

regi ao de converg encia como sendo 0.5, pois a fun c ao tamb em e de dif cil otimiza c ao: > testaotimizadores(funcao = hager, + vetor.busca.minimo = c(-10,-10), + vetor.busca.maximo = c(10,10), + quantidade.pontos = GERALquantidade.pontos, + ponto.otimo = c(1,1), + erro = GERALerro, + funcao.max = 60000, + maxiteracao = GERALmaxiteracao, + epsilon.convergencia = 0.5, + critCAG = GERALcritCAG, + critCEFO = GERALcritCEFO) $acertos.gradiente [1] 21 $media.itera c~ oes.gradiente [1] 2 $acertos.newton [1] 15 $media.itera c~ oes.newton [1] 1 $acertos.newtonmod [1] 15 $media.itera c~ oes.newtonmod [1] 1 $acertos.quasinewton.cp [1] 15 $media.itera c~ oes.quasinewton.cp [1] 1 $acertos.quasinewton.dfp [1] 15 $media.itera c~ oes.quasinewton.dfp [1] 1 $acertos.quasinewton.bfgs [1] 15 $media.itera c~ oes.quasinewton.bfgs [1] 1 $acertos.quasinewton.hb [1] 15 $media.itera c~ oes.quasinewton.hb [1] 1 $acertos.elipsoidal [1] 1

11

$media.itera c~ oes.elipsoidal [1] 11 $acertos.elipsoidal.deepcut [1] 55 $media.itera c~ oes.elipsoidal.deepcut [1] 68.89091

2.6

Fun c ao Eason

A fun c ao Eason apresenta um grande plat o e o m nimo ocorre um uma regi ao muito singular, o que faz dessa fun c ao uma das fun c oes mais dif ceis de se otimizar. Aqui usa-se uma regi ao de busca na qual |xi | < 100. Pelas caracter sticas dessa fun c ao a mesma e extremamente dif cil de se otimizar com os m etodos implementados. Resultados melhores s o s ao poss veis quando reduzimos consistentemente a regi ao de busca inicial. O sum ario em duas vari aveis ca da seguinte forma: > testaotimizadores(funcao = eason, + vetor.busca.minimo = c(-100,-100), + vetor.busca.maximo = c(100,100), + quantidade.pontos = GERALquantidade.pontos, + ponto.otimo = c(0,0), + erro = GERALerro, + funcao.max = 100, + maxiteracao = GERALmaxiteracao, + epsilon.convergencia = GERALepsilon.convergencia, + critCAG = GERALcritCAG, + critCEFO = GERALcritCEFO) $acertos.gradiente [1] 0 $media.itera c~ oes.gradiente [1] 0 $acertos.newton [1] 0 $media.itera c~ oes.newton [1] 0 $acertos.newtonmod [1] 0 $media.itera c~ oes.newtonmod [1] 0 $acertos.quasinewton.cp [1] 0 $media.itera c~ oes.quasinewton.cp [1] 0 $acertos.quasinewton.dfp [1] 0 $media.itera c~ oes.quasinewton.dfp [1] 0

12

$acertos.quasinewton.bfgs [1] 0 $media.itera c~ oes.quasinewton.bfgs [1] 0 $acertos.quasinewton.hb [1] 0 $media.itera c~ oes.quasinewton.hb [1] 0 $acertos.elipsoidal [1] 0 $media.itera c~ oes.elipsoidal [1] 0 $acertos.elipsoidal.deepcut [1] 0 $media.itera c~ oes.elipsoidal.deepcut [1] 0

2.7

Fun c ao Ackley

A fun c ao Ackley tamb em e de dif cil otimiza c ao. Aqui usa-se um intervalo de busca tal que |xi | < 5. O sum ario em duas vari aveis ca: > testaotimizadores(funcao = ackley, + vetor.busca.minimo = c(-5,-5), + vetor.busca.maximo = c(5,5), + quantidade.pontos = GERALquantidade.pontos, + ponto.otimo = c(0,0), + erro = GERALerro, + funcao.max = 50, + maxiteracao = GERALmaxiteracao, + epsilon.convergencia = GERALepsilon.convergencia, + critCAG = GERALcritCAG, + critCEFO = GERALcritCEFO) $acertos.gradiente [1] 63 $media.itera c~ oes.gradiente [1] 22.47619 $acertos.newton [1] 46 $media.itera c~ oes.newton [1] 4.826087 $acertos.newtonmod [1] 54 $media.itera c~ oes.newtonmod [1] 9.203704

13

$acertos.quasinewton.cp [1] 53 $media.itera c~ oes.quasinewton.cp [1] 3.773585 $acertos.quasinewton.dfp [1] 55 $media.itera c~ oes.quasinewton.dfp [1] 4.727273 $acertos.quasinewton.bfgs [1] 53 $media.itera c~ oes.quasinewton.bfgs [1] 3.735849 $acertos.quasinewton.hb [1] 53 $media.itera c~ oes.quasinewton.hb [1] 3.849057 $acertos.elipsoidal [1] 336 $media.itera c~ oes.elipsoidal [1] 63.52381 $acertos.elipsoidal.deepcut [1] 64 $media.itera c~ oes.elipsoidal.deepcut [1] 20.35938

2.8

Fun c ao Bukin

A fun c ao Bukin tamb em e um desao de otimiza c ao, pois o m nimo global se encontra em uma regi ao n ao diferenci avel juntamente com v arios m nimos locais. > testaotimizadores(funcao = bukin, + vetor.busca.minimo = c(-15,-3), + vetor.busca.maximo = c(-5,3), + quantidade.pontos = GERALquantidade.pontos, + ponto.otimo = c(-10,1), + erro = GERALerro, + funcao.max = 700, + maxiteracao = GERALmaxiteracao, + epsilon.convergencia = GERALepsilon.convergencia, + critCAG = GERALcritCAG, + critCEFO = GERALcritCEFO) $acertos.gradiente [1] 2 $media.itera c~ oes.gradiente [1] 138

14

$acertos.newton [1] 2 $media.itera c~ oes.newton [1] 4 $acertos.newtonmod [1] 2 $media.itera c~ oes.newtonmod [1] 5 $acertos.quasinewton.cp [1] 7 $media.itera c~ oes.quasinewton.cp [1] 13.14286 $acertos.quasinewton.dfp [1] 4 $media.itera c~ oes.quasinewton.dfp [1] 9.5 $acertos.quasinewton.bfgs [1] 1 $media.itera c~ oes.quasinewton.bfgs [1] 5 $acertos.quasinewton.hb [1] 1 $media.itera c~ oes.quasinewton.hb [1] 8 $acertos.elipsoidal [1] 23 $media.itera c~ oes.elipsoidal [1] 86.6087 $acertos.elipsoidal.deepcut [1] 3 $media.itera c~ oes.elipsoidal.deepcut [1] 503.6667

2.9

Fun c ao Three-hump Camel

A fun c ao Three-hump Camel e uma fun c ao com mal-condicionamento o que se revela uma problema interessante de otimiza c ao. > testaotimizadores(funcao = threehump, + vetor.busca.minimo = c(-5,-5), + vetor.busca.maximo = c(5,5), + quantidade.pontos = GERALquantidade.pontos, + ponto.otimo = c(0,0), + erro = GERALerro, 15

+ + + + + $acertos.gradiente [1] 20

funcao.max = 1000, maxiteracao = GERALmaxiteracao, epsilon.convergencia = GERALepsilon.convergencia, critCAG = GERALcritCAG, critCEFO = GERALcritCEFO)

$media.itera c~ oes.gradiente [1] 5.35 $acertos.newton [1] 58 $media.itera c~ oes.newton [1] 3.396552 $acertos.newtonmod [1] 70 $media.itera c~ oes.newtonmod [1] 3.8 $acertos.quasinewton.cp [1] 10 $media.itera c~ oes.quasinewton.cp [1] 6.3 $acertos.quasinewton.dfp [1] 10 $media.itera c~ oes.quasinewton.dfp [1] 6.3 $acertos.quasinewton.bfgs [1] 10 $media.itera c~ oes.quasinewton.bfgs [1] 6.5 $acertos.quasinewton.hb [1] 10 $media.itera c~ oes.quasinewton.hb [1] 6.5 $acertos.elipsoidal [1] 1 $media.itera c~ oes.elipsoidal [1] 2 $acertos.elipsoidal.deepcut [1] 4 $media.itera c~ oes.elipsoidal.deepcut [1] 7.25 16

2.10

Fun c ao Schaer2

A fun c ao Schaer2 e uma fun c ao altamente irregular e tamb em de dif cil otimiza c ao. Afrouxando o epsilon do intervalo de converg encia para = 1 obtemos um fracasso da maioria dos m etodos: > testaotimizadores(funcao = schaffer2, + vetor.busca.minimo = c(-100,-100), + vetor.busca.maximo = c(100,100), + quantidade.pontos = GERALquantidade.pontos, + ponto.otimo = c(0,0), + erro = GERALerro, + funcao.max = 10, + maxiteracao = GERALmaxiteracao, + epsilon.convergencia = 1, + critCAG = GERALcritCAG, + critCEFO = GERALcritCEFO) $acertos.gradiente [1] 0 $media.itera c~ oes.gradiente [1] 0 $acertos.newton [1] 0 $media.itera c~ oes.newton [1] 0 $acertos.newtonmod [1] 1 $media.itera c~ oes.newtonmod [1] 2 $acertos.quasinewton.cp [1] 1 $media.itera c~ oes.quasinewton.cp [1] 4 $acertos.quasinewton.dfp [1] 1 $media.itera c~ oes.quasinewton.dfp [1] 4 $acertos.quasinewton.bfgs [1] 1 $media.itera c~ oes.quasinewton.bfgs [1] 4 $acertos.quasinewton.hb [1] 2 $media.itera c~ oes.quasinewton.hb [1] 5 $acertos.elipsoidal 17

[1] 0 $media.itera c~ oes.elipsoidal [1] 0 $acertos.elipsoidal.deepcut [1] 0 $media.itera c~ oes.elipsoidal.deepcut [1] 0

2.11

Fun c ao Styblinskitang

Por m a fun c ao Styblinskitang e uma fun c ao que apresenta quatro fortes bacias de atra c ao, mas apenas uma cont em o m nimo: > testaotimizadores(funcao = styblinskitang, + vetor.busca.minimo = c(-5,-5), + vetor.busca.maximo = c(5,5), + quantidade.pontos = GERALquantidade.pontos, + ponto.otimo = c(-2.903534,-2.903534), + erro = GERALerro, + funcao.max = 10, + maxiteracao = GERALmaxiteracao, + epsilon.convergencia = GERALepsilon.convergencia, + critCAG = GERALcritCAG, + critCEFO = GERALcritCEFO) $acertos.gradiente [1] 385 $media.itera c~ oes.gradiente [1] 13.76104 $acertos.newton [1] 237 $media.itera c~ oes.newton [1] 3.43038 $acertos.newtonmod [1] 333 $media.itera c~ oes.newtonmod [1] 5.624625 $acertos.quasinewton.cp [1] 375 $media.itera c~ oes.quasinewton.cp [1] 9.976 $acertos.quasinewton.dfp [1] 434 $media.itera c~ oes.quasinewton.dfp [1] 8.670507 $acertos.quasinewton.bfgs 18

[1] 248 $media.itera c~ oes.quasinewton.bfgs [1] 8.342742 $acertos.quasinewton.hb [1] 269 $media.itera c~ oes.quasinewton.hb [1] 10.79554 $acertos.elipsoidal [1] 156 $media.itera c~ oes.elipsoidal [1] 21.44231 $acertos.elipsoidal.deepcut [1] 123 $media.itera c~ oes.elipsoidal.deepcut [1] 1.479675

Conclus ao

Dados os resultados apresentados nos testes feitos nota-se que os diferentes m etodos s ao mais ou menos ecientes dependendo da fun c ao que se pretende otimizar. O fato de ter-se testado os v arios m etodos para v arias fun c oes diferentes mostrou que as implementa c oes precisam ir al em dos seus esbo cos iniciais para realizarem um bom trabalho de otimiza c ao. Diga-se de passagem que a fun c ao Eason permitiu um grande aprendizado sobre como lidar com fun c oes onde o c alculo do gradiente num erico n ao e poss vel na maioria dos pontos.

Anexos
Aqui est ao os algoritmos que foram usados em nosso relat orio:

Algoritmos Preliminares
Gradiente Num erico Algor tmo simples para c alculo do gradiente num erico. > gradiente <- function(funcao, + ponto, + delta = 0.0001){ + nvar <- length(ponto); + I <- rep(1,nvar); + g <- NULL; + k <- 0; + for(i in 1:nvar){ + c <- I; + c[i] <- 0; + e <- I - c; + g[i] <- (funcao(ponto + delta*e) - funcao(ponto))/delta; + while(is.na(g[i])){ + delta <- 1.5*delta; + g[i] <- (funcao(ponto + delta*e) - funcao(ponto))/delta; + k <- k + 1; 19

+ if(k == 20){ + g <- NULL; + return(g) + } + } + } + return(g); + } Subgradiente Num erico Essa fun c ao basicamente e igual a fun ca o do c alculo do gradiente num erico. > subgradiente <- function(funcao, + ponto){ + g <- gradiente(funcao,ponto); + return(g) + } Hessiana Num erica Altoritmo que calcula a hessiana numericamente. > hessiana <- function(funcao, + ponto, + delta = 0.0001){ + ponto <- as.matrix(ponto); + nvar <- nrow(ponto); + I <- rep(1,nvar); + h <- NULL; + H <- NULL; + for(i in 1:nvar){ + c <- I; + c[i] <- 0; + e <- I - c; + nh <- (gradiente(funcao,ponto + delta*e,delta) - gradiente(funcao,ponto,delta))/delta; + h <- as.vector(H); + H <- matrix(c(h,nh),nrow = nvar); + } + return(H) + } Otimiza c ao Univariada Essa fun c ao coordena a otimiza c ao univariada que ser a feita em todos os algoritmos implementados. Basicamente ela e uma adapta c ao do m etodo da se c ao aurea. > otimizacaminho <- function(funcao, + ponto, + erro = 0.001, + direcao = gradiente(funcao,ponto)){ + i <- 0; + a <- 0; + b <- abs((1/erro)*max(direcao)); + bmax <- 1e+10; + bmin <- 10; + if(is.na(b)){b <- bmax}; + if(b > bmax){ + b <- bmax; + } 20

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + }

if(b < bmin){ b <- bmin; } fun <- NULL; while(b - a > erro){ i <- i + 1; xa <- b - 0.618*(b - a); xb <- a + 0.618*(b - a); fa <- funcao(ponto - xa*direcao); fb <- funcao(ponto - xb*direcao); if(!(is.nan(fa))&&!(is.nan(fb))){ if(fa < fb){ b <- xb; fun <- fa; }else{ a <- xa; fun <- fb; } }else{ break; } } alpha <- (a + b)/2; return(list( alpha = alpha, funcao.otimizada = fun, iteracoes = i) );

M etodo do Gradiente
> metodogradiente <- function(funcao, + ponto, + maxiteracao = 1000, + erro=0.001, + funcao.max = NULL, + critCAG = 0.001, + critCEFO = 0.001){ + x <- ponto; + i <- 0; + fun <- funcao(x); + CEFO <- critCEFO + 1; + CAG <- critCAG + 1; + NormaGradiente <- NULL; + xmin <- NULL; + while((i < maxiteracao) && (CAG > critCAG) && (CEFO > critCEFO)){ + i <- i + 1; + g <- gradiente(funcao,x); + if(is.null(g) && (sum(g^2)==0)){ + break; + } + direcao <- g; + alpha <- otimizacaminho(funcao, + ponto = x, + erro = erro, + direcao = direcao)$alpha; + x <- x - alpha*direcao;

21

+ fun[i+1] <- funcao(x); + if(fun[i + 1] <= min(fun)){ + xmin <- x; + } + NormaGradiente[i] <- sqrt(sum(g^2)); + CAG <- NormaGradiente[i]/max(NormaGradiente); + if(i >= 5){ + CEFO <- (max(fun[(i-4):i])-min(fun[(i-4):i]))/(max(fun)-min(fun)); + if(fun[i-3]<fun[i-2] && fun[i-2]<fun[i-1] && fun[i-1]<fun[i]){ + break; + } + } + if(!is.null(funcao.max)){ + if(fun[i+1] > funcao.max){ + break; + } + } + if(is.nan(CAG)||is.nan(CEFO)){ + break; + } + } + return(list( + ponto.otimizado = xmin, + funcao.otimizada = min(fun), + itera c~ oes = i, + vetor.minimos = fun + )) + }

M etodo de Newton
> metodonewton <- function(funcao, + ponto, + maxiteracao = 1000, + funcao.max = NULL, + critCAG = 0.001, + critCEFO = 0.001){ + x <- ponto; + i <- 0; + NormaGradiente <- NULL; + fun <- funcao(x); + CEFO <- critCEFO + 1; + CAG <- critCAG + 1; + xmin <- NULL; + while((i < maxiteracao) && (CAG > critCAG) && (CEFO > critCEFO)){ + i <- i + 1; + g <- gradiente(funcao,x); + if(is.null(g) && (sum(g^2)==0)){ + break; + } + H <- hessiana(funcao,x); + if(det(H)==0){break;} + x <- as.vector(x - solve(H)%*%g); + fun[i+1] <- funcao(x) + if(fun[i + 1] <= min(fun)){ + xmin <- x; + } + NormaGradiente[i] <- sqrt(sum(g^2));

22

+ CAG <- NormaGradiente[i]/max(NormaGradiente); + if(i >= 5){ + CEFO <- (max(fun[(i-4):i])-min(fun[(i-4):i]))/(max(fun)-min(fun)); + if(fun[i-3]<fun[i-2] && fun[i-2]<fun[i-1] && fun[i-1]<fun[i]){ + break; + } + } + if(!is.null(funcao.max)){ + if(fun[i+1] > funcao.max){ + break; + } + } + if(is.nan(CAG)||is.nan(CEFO)){ + break; + } + } + return(list( + ponto.otimizado = xmin, + funcao.otimizada = min(fun), + itera c~ oes = i, + vetor.minimos = fun + )) + }

M etodo de Newton Modicado

> metodonewtonmod <- function(funcao, + ponto, + maxiteracao = 1000, + erro=0.001, + funcao.max = NULL, + critCAG = 0.001, + critCEFO = 0.001){ + x <- ponto; + i <- 0; + NormaGradiente <- NULL; + fun <- funcao(x); + CEFO <- critCEFO + 1; + CAG <- critCAG + 1; + xmin <- NULL; + while((i < maxiteracao) && (CAG > critCAG) && (CEFO > critCEFO)){ + i <- i + 1; + g <- gradiente(funcao,x); + if(is.null(g) && (sum(g^2)==0)){ + break; + } + H <- hessiana(funcao,x); + if(det(H)==0){break;} + direcao <- -solve(H)%*%g; + alpha <- otimizacaminho(funcao, + x, + direcao = -direcao, + erro = erro)$alpha; + x <- as.vector(x + alpha*direcao); + fun[i+1] <- funcao(x) + if(fun[i + 1] <= min(fun)){ + xmin <- x; + }

23

+ NormaGradiente[i] <- sqrt(sum(g^2)); + CAG <- NormaGradiente[i]/max(NormaGradiente); + if(i >= 5){ + CEFO <- (max(fun[(i-4):i])-min(fun[(i-4):i]))/(max(fun)-min(fun)); + if(fun[i-3]<fun[i-2] && fun[i-2]<fun[i-1] && fun[i-1]<fun[i]){ + break; + } + } + if(!is.null(funcao.max)){ + if(fun[i+1] > funcao.max){ + break; + } + } + if(is.nan(CAG)||is.nan(CEFO)){ + break; + } + } + return(list( + ponto.otimizado = xmin, + funcao.otimizada = min(fun), + itera c~ oes = i, + vetor.minimos = fun + )) + }

M etodo QuasiNewton
> metodoquasinewton <- function(funcao, + ponto, + metodo="correcaoposto", + maxiteracao = 1000, + erro=0.001, + funcao.max = NULL, + critCAG = 0.001, + critCEFO = 0.001){ + x <- ponto; + fun <- funcao(x); + n <- length(ponto); + QuasiH <- matrix(data = rep(x=0,n^2),nrow = n,ncol = n); + for(j in 1:n){ + for(k in 1:n){ + if(k==j){QuasiH[j,k] <- 1;} + } + } + i <- 0; + NormaGradiente <- NULL; + CEFO <- critCEFO + 1; + CAG <- critCAG + 1; + xmin <- NULL; + g <- gradiente(funcao,x); + if(!is.null(g) && !(sum(g^2)==0)){ + while((i < maxiteracao) && (CAG > critCAG) && (CEFO > critCEFO)){ + i <- i + 1; + direcao <- -as.vector(QuasiH%*%g); + alpha <- otimizacaminho(funcao, + x, + direcao = -direcao, + erro = erro)$alpha;

24

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

nx <- as.vector(x + alpha*direcao); ng <- gradiente(funcao,nx); if(is.null(ng) || sum(ng^2)==0){ break; } v <- x - nx; r <- g - ng; x <- nx; g <- ng; fun[i + 1] <- funcao(x) if(fun[i + 1] <= min(fun)){ xmin <- x; } if(metodo == "correcaoposto"){ aux1 <- v - QuasiH%*%r; aux2 <- as.vector(1/(t(r)%*%aux1)); QuasiH <- QuasiH + aux2*(aux1%*%t(aux1)); }else if(metodo == "DFP"){ aux1 <- (v%*%t(v))/(as.vector(t(v)%*%r)); aux2 <- (QuasiH%*%r%*%t(r)%*%QuasiH)/as.vector((t(r)%*%QuasiH%*%r)) QuasiH <- QuasiH + aux1 - aux2; }else if(metodo == "BFGS"){ aux1a <- ((1 + (as.vector(t(r)%*%QuasiH%*%r))/as.vector((t(v)%*%r)))); aux1b <- ((v%*%t(v)) / (as.vector(t(v)%*%r))); aux1 <- aux1a*aux1b; aux2 <- (v%*%t(r)%*%QuasiH+QuasiH%*%r%*%t(v))/as.vector((t(r)%*%QuasiH%*%v)) QuasiH <- QuasiH + aux1 - aux2; }else if(metodo == "hibrido"){ aux1a <- ((1 + (as.vector(t(r)%*%QuasiH%*%r))/as.vector((t(v)%*%r)))); aux1b <- ((v%*%t(v)) / (as.vector(t(v)%*%r))); aux1 <- aux1a*aux1b; aux2 <- (v%*%t(r)%*%QuasiH+QuasiH%*%r%*%t(v))/as.vector((t(r)%*%QuasiH%*%v)); BFGS <- aux1 - aux2; aux3 <- (v%*%t(v))/(as.vector(t(v)%*%r)); aux4 <- (QuasiH%*%r%*%t(r)%*%QuasiH)/as.vector((t(r)%*%QuasiH%*%r)); DFP <- aux3 - aux4; aux5 <- 0.3*abs(fun[i]/max(fun)); QuasiH <- QuasiH + (0.7 - aux5)*BFGS + (0.3 + aux5)*DFP; } NormaGradiente[i] <- sqrt(sum(g^2)); CAG <- NormaGradiente[i]/max(NormaGradiente); if(i >= 5){ CEFO <- (max(fun[(i-4):i])-min(fun[(i-4):i]))/(max(fun)-min(fun)); if(fun[i-3]<fun[i-2] && fun[i-2]<fun[i-1] && fun[i-1]<fun[i]){ break; } } if(!is.null(funcao.max)){ if(fun[i+1] > funcao.max){ break; } } if(is.nan(CAG)||is.nan(CEFO)){ break; } } } return(list(

25

+ ponto.otimizado = xmin, + funcao.otimizada = min(fun), + itera c~ oes = i, + vetor.minimos = fun + )) + }

M etodo Elipsoidal
> metodoelipsoidal <- function(funcao, + ponto, + Q0 = 0, + deepcut.intensidade = 0, + maxiteracao = 1000, + funcao.max = NULL, + critCEFO = 0.001){ + i <- 0; + x <- ponto; + n <- length(x); + if(sum(abs(Q0)) == 0){ + Q <- matrix(data = rep(x = 0,n^2),nrow = n,ncol = n); + for(j in 1:n){ + for(k in 1:n){ + if(k==j){Q[j,k] <- sum(ponto^2);} + } + } + }else{ + Q <- Q0; + } + CEFO <- critCEFO + 1; + xmin <- NULL; + if(n != nrow(Q) || n != ncol(Q)){ + return("ponto e Q0 incompat veis.") + } + if(deepcut.intensidade <= 1/n){ + alpha <- deepcut.intensidade; + }else{ + alpha <- 1/n + } + beta1 <- (1+n*alpha)/(n+1); + beta2 <- ((1-alpha^2)*(n^2))/(n^2-1); + beta3 <- 2*(1-n*alpha)/((n+1)*(1+alpha)); + fun <- funcao(x); + while((i < maxiteracao) && (CEFO > critCEFO)){ + i <- i + 1; + g <- subgradiente(funcao, + x); + if(is.null(g) || (sum(g^2)==0)){ + break; + } + aux1 <- as.vector(Q%*%g); + aux2 <- as.vector(t(g)%*%aux1); + x <- x - beta1*(1/sqrt(aux2))*aux1; + fun[i + 1] <- funcao(x); + if(!is.nan(fun[i + 1])){ + if(fun[i + 1] <= min(fun)){ + xmin <- x; + }

26

+ } + Q <- beta2*(Q - (beta3*aux1%*%t(aux1))/(aux2)); + if(i >= 5){ + CEFO <- (max(fun[(i-4):i])-min(fun[(i-4):i]))/(max(fun)-min(fun)); + if(fun[i-3]<fun[i-2] && fun[i-2]<fun[i-1] && fun[i-1]<fun[i]){ + break; + } + } + if(!is.null(funcao.max)){ + if(fun[i+1] > funcao.max){break;} + } + if(is.nan(CEFO)){ + break; + } + } + return(list( + ponto.otimizado = xmin, + funcao.otimizada = min(fun), + itera c~ oes = i, + vetor.minimos = fun + )) + }

Fun co es de Teste
Fun c ao Esfera A fun c ao esfera e denida para todo x Rn pela lei::
n

f (x) =
i=1

x2 i

A implementa c ao em R usada nos testes e bastante simples: > esfera <- function(ponto){ + z <- sum(ponto^2); + return(z) + } A fun c ao esfera pode ser testada para qualquer raio de busca de tal forma que o m nimo ser a zero e ocorre somente na origem, independentemente do valor de n. > ponto1d <- 0; ponto2d <- c(0,0); ponto3d <- c(0,0,0); ponto10d <- rep(0,10); > esfera(ponto1d); [1] 0 > esfera(ponto2d); [1] 0 > esfera(ponto3d); [1] 0 > esfera(ponto10d); [1] 0

27

0 1 2 2

Figura 1: Fun c ao esfera em duas dimens oes Fun c ao Beale A Fun c ao Beale e denida para todo x R2 pela lei: f (x, y ) = (1.5 x + xy )2 + (2.25 x + xy 2 )2 + (2.625 x + xy 3 )2 A implementa c ao em R usada foi: > beale <- function(ponto){ + x <- ponto[1]; + y <- ponto[2]; + z <- (1.5 - x + x*y)^2 + (2.25 - x + x*y^2)^2 + (2.625 - x + x*y^3)^2 + return(z) + } A fun c ao Beale apresenta como raio de busca ideal |xi | < 4.5. O valor m nimo e zero e ocorre no unicamente no ponto (3,0.5). > ponto <- c(3,0.5) > beale(ponto) [1] 0

Fun c ao Rosenbrock A fun c ao Rosenbrock e denida para todo x Rn com n > 1 pela lei: 28

f(x,y)
4 2 1 2 1 0 2

150000

100000

2
x

0 2 4 4

Figura 2: Fun c ao Beale em duas dimens oes

n/2

f (x) =
i=1

2 2 100(x2 2i1 x2i ) + (x2i1 1)

A implementa c ao usada foi: > rosenbrock <- function(ponto){ + x <- ponto + n <- length(x) + z <- 0; + for(i in 1:(n/2)){ + z <- z + 100*(x[2*i-1]^2-x[2*i])^2+(x[2*i-1]-1)^2; + } + return(z); + } O raio de busca ideal para essa fun c ao e tal que |xi | < 2, 4. Esta fun c ao assume valor m nimo zero em qualquer dimens ao n. O m nimo eu nico e ocorre no ponto (1, 1, . . . , 1). > ponto2d <- c(1,1); ponto3d <- c(1,1,1); ponto10d <- rep(1,10); > rosenbrock(ponto2d); [1] 0 > rosenbrock(ponto3d); 29

f(x,y)

50000 0 4 0 2

[1] 0 > rosenbrock(ponto10d); [1] 0

6000

1
x

0 1 2 2

Figura 3: Fun c ao Rosenbrock em duas dimens oes

Fun c ao Rastringin A fun c ao Rastringin e denida para todo x Rn pela lei:

n

f (x) = 10n +
i=1

x2 i 10 cos(2xi )

A implementa c ao usada foi: > rastringin <- function(ponto){ + x <- ponto; + n <- length(x); + z <- 10*n; + for(i in 1:n){ + z <- z + x[i]^2 - 10*cos(2*pi*x[i]); + } + return(z); + }

30

f(x,y)

4000

2000 2 1 2 0

O raio de busca ideal para essa fun c ao e tal que |xi | < 5, 12. Esta fun c ao assume valor m nimo zero em qualquer dimens ao n. O m nimo eu nico e ocorre na origem. > ponto1d <- 0; ponto2d <- c(0,0); ponto3d <- c(0,0,0); ponto10d <- rep(0,10); > rastringin(ponto1d); [1] 0 > rastringin(ponto2d); [1] 0 > rastringin(ponto3d); [1] 0 > rastringin(ponto10d); [1] 0

80

60

2
x

0 2 4

2 4

Figura 4: Fun c ao Rastringin em duas dimens oes

Fun c ao Hager A fun c ao Hager e denida para todo x Rn pela lei:

n

f (x) =
i=1

exp xi

ixi

A implementa c ao usada foi: 31

f(x,y)
40 20 2 4 0 4

> hager <- function(ponto){ + x <- ponto; + z <- 0; + for(i in 1:length(ponto)){ + z <- z + exp(x[i])-sqrt(i)*x[i]; + } + return(z) + } O raio de busca ideal para essa fun c ao e tal que |xi | < 10. Esta fun c ao assume valor m nimo vari avel dependendo do valor de n, por em o m nimo eu nico e ocorre no ponto (1, 1, . . . , 1). > ponto1d <- 1; ponto2d <- c(1,1); ponto3d <- c(1,1,1); ponto10d <- rep(1,10); > hager(ponto1d); [1] 1.718282 > hager(ponto2d); [1] 3.02235 > hager(ponto3d); [1] 4.008581 > hager(ponto10d); [1] 4.71454 Fun c ao Eason A fun c ao Eason e denida para todo x Rn pela lei:
n n

f (x) = (1)n
i=1

cos(xi ) exp
i=1

( xi ) 2

A implementa c ao usada foi: > eason <- function(ponto){ + n <- length(ponto); + z1 <- -1; + z2 <- 0; + for(i in 1:n){ + z1 <- z1*cos(ponto[i]); + z2 <- z2 + (ponto[i]-pi)^2; + } + z <- ((-1)^n)*z1*exp(-z2) + return(z) + } O raio de busca ideal para essa fun c ao e tal que |xi | < 100. Esta fun c ao assume valor m nimo igual a -1 para todo n, o m nimo eu nico e ocorre no ponto (, , . . . , ) > ponto1d <- pi; ponto2d <- c(pi,pi); ponto3d <- c(pi,pi,pi); ponto10d <- rep(pi,10); > eason(ponto1d); [1] -1 > eason(ponto2d); [1] -1 > eason(ponto3d); [1] -1 > eason(ponto10d); [1] -1

32

40000

30000

0 5 1010

Figura 5: Fun c ao Hager em duas dimens oes Fun c ao Ackley A fun c ao Ackley e denida para todo (x, y ) R2 pela lei: f (x, y ) = 20 exp 0.2 A implementa c ao usada foi: > ackley <- function(ponto){ + x <- ponto; + z <- -20*exp(-0.2*sqrt(0.5*sum(x^2)))-exp(0.5*sum(cos(2*pi*x)))+20+exp(1); + return(z) + } O raio de busca ideal para essa fun c ao e tal que |xi | < 5. Esta fun c ao assume valor m nimo igual a 0, o m nimo eu nico e ocorre na origem. > ponto <- c(0,0); > ackley(ponto); [1] 4.440892e-16 0.5(x2 + y 2 ) exp(0.5(cos(2x) + cos(2y ))) + 20 + e

Fun c ao Bukin A fun c ao Bukin e denida para todo (x, y ) R2 pela lei:

33

f(x,y)

20000 10000 10 5 10 5 0

0.0

0.2

0 50

50 100 100

Figura 6: Fun c ao Eason em duas dimens oes

f (x, y ) = 100 A implementa c ao usada foi:

|y 0, 01x2 | + 0, 01|x + 10|

> bukin <- function(ponto){ + x <- ponto[1] + y <- ponto[2] + z <- 100*sqrt(abs(y-0.01*x^2))+0.01*abs(x+10); + return(z) + } O raio de busca ideal para essa fun c ao e tal que 15 < x < 5 e 3 < y < 3. Esta fun c ao assume valor m nimo igual a 0, o m nimo eu nico e ocorre no ponto (10, 1). > ponto <- c(-10,1); > bukin(ponto); [1] 0 Fun c ao Three-hump camel A fun c ao Three-hump camel e denida para todo x Rn com n par pela lei:
n/2

f (x) =
i=1

6 2 2x2i1 1.05x4 2i1 + x2i1 /6 + x2i1 x2i + x2i

34

f(x,y)
0.4 100 0.6 100 50 0 50

10

2
x

0 2 4

2 4

Figura 7: Fun c ao Ackley em duas dimens oes A implementa c ao usada foi: > threehump <- function(ponto){ + z <- 0. + x <- ponto; + n <- length(ponto) + for(i in 1:(n/2)){ + z <- z + (2*(x[2*i-1]^2-1.05*x[2*i-1]^4+x[2*i-1]^6/6+x[2*i-1]*x[2*i]+x[2*i]^2))/2; + } + return(z) + } O raio de busca ideal para essa fun c ao e tal que |xi | < 5. Esta fun c ao assume valor m nimo igual a 0, o m nimo eu nico e ocorre na origem. > ponto <- c(0,0); > threehump(ponto); [1] 0 Fun c ao Schaer2 A fun c ao Schaer2 e denida para todo (x, y ) R2 pela lei: f (x, y ) = 0.5 + sin2 (x2 + y 2 ) 0.5 (1 + 0.001(x2 + y 2 ))2 35

f(x,y)
5 4 2 4 0

400

300

5
x

0 5 10 1515

5 10

Figura 8: Fun c ao Bukin em duas dimens oes A implementa c ao usada foi: > schaffer2 <- function(ponto){ + x <- ponto[1] + y <- ponto[2] + z <- 0.5 + ((sin(x^2-y^2))^2-0.5)/(1+0.001*(x^2+y^2))^2 + return(z) + } O raio de busca ideal para essa fun c ao e tal que |xi | < 100. Esta fun c ao assume valor m nimo igual a 0, o m nimo eu nico e ocorre na origem. > ponto <- c(0,0); > schaffer2(ponto); [1] 0

Fun c ao Styblinskitang A fun c ao Styblinskitang e denida para todo (x, y ) R2 pela lei: f (x, y ) = 0.5 + A implementa c ao usada foi: sin2 (x2 + y 2 ) 0.5 (1 + 0.001(x2 + y 2 ))2

36

f(x,y)

200 100 15 10 15 10 5 0

2000

1500

2
x

0 2 4

2 4

Figura 9: Fun c ao Three-hump camel em duas dimens oes > styblinskitang <- function(ponto){ + x <- ponto; + n <- length(x); + z <- 0; + for(i in (1:n)){ + z <- z + (x[i]^4-16*x[i]^2+5*x[i])/2 + } + return(z) + } O raio de busca ideal para essa fun c ao e tal que |xi | < 5. Esta fun c ao assume valor m nimo igual a -39.16599n, o m nimo eu nico e ocorre no ponto (2.903534, 2.903534, . . . , 2.903534). > x <- -2.903534 > ponto1d <- x; ponto2d <- rep(x,2); ponto3d <- rep(x,3); ponto10d <- rep(x,10); > styblinskitang(ponto1d); [1] -39.16617 > styblinskitang(ponto2d); [1] -78.33233 > styblinskitang(ponto3d); [1] -117.4985 37

f(x,y)

1000 500 0 4 0 2

0.8 0.6

0 50

50 100 100

Figura 10: Fun c ao Schaer2 em duas dimens oes > styblinskitang(ponto10d); [1] -391.6617

(
Algoritmo de teste dos otimizadores) Criou-se uma fun c ao u nica para controlar o procedimento de teste de todos os otimizadores para cada uma das fun c oes de teste denidas anteriormente. > testaotimizadores <- function(funcao, + vetor.busca.minimo, + vetor.busca.maximo, + quantidade.pontos = 100, + ponto.otimo, + maxiteracao = 1000, + funcao.max = NULL, + erro = 0.001, + epsilon.convergencia = 0.001, + critCAG = 0.0001, + critCEFO = 0.0001){ + + ec <- epsilon.convergencia; + qp <- quantidade.pontos;

38

f(x,y)

0.4 0.2 100 50 100 50 0

200

2
x

0 2 4

2 4

Figura 11: Fun c ao Styblinskitang em duas dimens oes + + + + + + + + + + + + + + + + + + + + + + + + po <- ponto.otimo; vbmin <- vetor.busca.minimo; vbmax <- vetor.busca.maximo; ndim <- length(vbmin); liminf <- NULL; limsup <- NULL; multiplicador.elipsoide <- sum(vbmax^2+vbmin^2); if(multiplicador.elipsoide < 1){ multiplicador.elipsoide <- 1/multiplicador.elipsoide; } elipsoide <- matrix(data = rep(x = 0,ndim^2),nrow = ndim,ncol = ndim); intervalo.acerto <- cbind(po - ec,po + ec); for(j in 1:ndim){ for(k in 1:ndim){ if(k==j){elipsoide[j,k] <- multiplicador.elipsoide;} } } acertos.gradiente <- 0; itera c~ oes.gradiente <- 0; acertos.newton <- 0; itera c~ oes.newton <- 0; acertos.newtonmod <- 0; itera c~ oes.newtonmod <- 0; acertos.quasinewton.cp <- 0;

39

f(x,y)

100

0 2 4 0

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

itera c~ oes.quasinewton.cp <- 0; acertos.quasinewton.dfp <- 0; itera c~ oes.quasinewton.dfp <- 0; acertos.quasinewton.bfgs <- 0; itera c~ oes.quasinewton.bfgs <- 0; acertos.quasinewton.hb <- 0; itera c~ oes.quasinewton.hb <- 0; acertos.elipsoidal <- 0; itera c~ oes.elipsoidal <- 0; acertos.elipsoidal.dc <- 0; itera c~ oes.elipsoidal.dc <- 0; for(iqp in 1:qp){ ponto.aleatorio <- NULL; for(ivetor in 1:ndim){ ponto.aleatorio[ivetor] <- runif(n = 1,min = vbmin[ivetor],max = vbmax[ivetor]); } extrato <- metodogradiente(funcao = funcao, ponto = ponto.aleatorio, maxiteracao = maxiteracao, erro = erro, critCAG = critCAG, critCEFO = critCEFO); for(indim in 1:ndim){ if(is.null(extrato$ponto.otimizado)){ break; } liminf[indim] <- extrato$ponto.otimizado[indim] > intervalo.acerto[indim,1]; limsup[indim] <- extrato$ponto.otimizado[indim] < intervalo.acerto[indim,2]; } if(sum(liminf) == ndim && sum(limsup) == ndim){ acertos.gradiente <- acertos.gradiente + 1; itera c~ oes.gradiente[acertos.gradiente] <- extrato$itera c~ oes; } extrato <- metodonewton(funcao = funcao, ponto = ponto.aleatorio, maxiteracao = maxiteracao, funcao.max = funcao.max, critCAG = critCAG, critCEFO = critCEFO); for(indim in 1:ndim){ if(is.null(extrato$ponto.otimizado)){ break; } liminf[indim] <- extrato$ponto.otimizado[indim] > intervalo.acerto[indim,1]; limsup[indim] <- extrato$ponto.otimizado[indim] < intervalo.acerto[indim,2]; } if(sum(liminf) == ndim && sum(limsup) == ndim){ acertos.newton <- acertos.newton + 1; itera c~ oes.newton[acertos.newton] <- extrato$itera c~ oes; } extrato <- metodonewtonmod(funcao = funcao, ponto = ponto.aleatorio, maxiteracao = maxiteracao, funcao.max = funcao.max, erro = erro, critCAG = critCAG, critCEFO = critCEFO); for(indim in 1:ndim){

40

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

if(is.null(extrato$ponto.otimizado)){ break; } liminf[indim] <- extrato$ponto.otimizado[indim] > intervalo.acerto[indim,1]; limsup[indim] <- extrato$ponto.otimizado[indim] < intervalo.acerto[indim,2]; } if(sum(liminf) == ndim && sum(limsup) == ndim){ acertos.newtonmod <- acertos.newtonmod + 1; itera c~ oes.newtonmod[acertos.newtonmod] <- extrato$itera c~ oes; } extrato <- metodoquasinewton(funcao = funcao, ponto = ponto.aleatorio, metodo = "correcaoposto", maxiteracao = maxiteracao, erro = erro, funcao.max = funcao.max, critCAG = critCAG, critCEFO = critCEFO); for(indim in 1:ndim){ if(is.null(extrato$ponto.otimizado)){ break; } liminf[indim] <- extrato$ponto.otimizado[indim] > intervalo.acerto[indim,1]; limsup[indim] <- extrato$ponto.otimizado[indim] < intervalo.acerto[indim,2]; } if(sum(liminf) == ndim && sum(limsup) == ndim){ acertos.quasinewton.cp <- acertos.quasinewton.cp + 1; itera c~ oes.quasinewton.cp[acertos.quasinewton.cp] <- extrato$itera c~ oes; } extrato <- metodoquasinewton(funcao = funcao, ponto = ponto.aleatorio, metodo = "DFP", maxiteracao = maxiteracao, erro = erro, critCAG = critCAG, critCEFO = critCEFO); for(indim in 1:ndim){ if(is.null(extrato$ponto.otimizado)){ break; } liminf[indim] <- extrato$ponto.otimizado[indim] > intervalo.acerto[indim,1]; limsup[indim] <- extrato$ponto.otimizado[indim] < intervalo.acerto[indim,2]; } if(sum(liminf) == ndim && sum(limsup) == ndim){ acertos.quasinewton.dfp <- acertos.quasinewton.dfp + 1; itera c~ oes.quasinewton.dfp[acertos.quasinewton.dfp] <- extrato$itera c~ oes; } extrato <- metodoquasinewton(funcao = funcao, ponto = ponto.aleatorio, metodo = "BFGS", maxiteracao = maxiteracao, erro = erro, funcao.max = funcao.max, critCAG = critCAG, critCEFO = critCEFO); for(indim in 1:ndim){ if(is.null(extrato$ponto.otimizado)){ break;

41

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

} liminf[indim] <- extrato$ponto.otimizado[indim] > intervalo.acerto[indim,1]; limsup[indim] <- extrato$ponto.otimizado[indim] < intervalo.acerto[indim,2]; } if(sum(liminf) == ndim && sum(limsup) == ndim){ acertos.quasinewton.bfgs <- acertos.quasinewton.bfgs + 1; itera c~ oes.quasinewton.bfgs[acertos.quasinewton.bfgs] <- extrato$itera c~ oes; } extrato <- metodoquasinewton(funcao = funcao, ponto = ponto.aleatorio, metodo = "hibrido", maxiteracao = maxiteracao, erro = erro, funcao.max = funcao.max, critCAG = critCAG, critCEFO = critCEFO); for(indim in 1:ndim){ if(is.null(extrato$ponto.otimizado)){ break; } liminf[indim] <- extrato$ponto.otimizado[indim] > intervalo.acerto[indim,1]; limsup[indim] <- extrato$ponto.otimizado[indim] < intervalo.acerto[indim,2]; } if(sum(liminf) == ndim && sum(limsup) == ndim){ acertos.quasinewton.hb <- acertos.quasinewton.hb + 1; itera c~ oes.quasinewton.hb[acertos.quasinewton.hb] <- extrato$itera c~ oes; } extrato <- metodoelipsoidal(funcao = funcao, ponto = ponto.aleatorio, Q0 = elipsoide, deepcut.intensidade = 0, maxiteracao = maxiteracao, funcao.max = funcao.max, critCEFO = critCEFO); for(indim in 1:ndim){ if(is.null(extrato$ponto.otimizado)){ break; } liminf[indim] <- extrato$ponto.otimizado[indim] > intervalo.acerto[indim,1]; limsup[indim] <- extrato$ponto.otimizado[indim] < intervalo.acerto[indim,2]; } if(sum(liminf) == ndim && sum(limsup) == ndim){ acertos.elipsoidal <- acertos.elipsoidal + 1; itera c~ oes.elipsoidal[acertos.elipsoidal] <- extrato$itera c~ oes; } extrato <- metodoelipsoidal(funcao = funcao, ponto = ponto.aleatorio, Q0 = elipsoide, deepcut.intensidade = 1/(4*ndim), funcao.max = funcao.max, maxiteracao = maxiteracao, critCEFO = critCEFO); for(indim in 1:ndim){ if(is.null(extrato$ponto.otimizado)){ break; } liminf[indim] <- extrato$ponto.otimizado[indim] > intervalo.acerto[indim,1]; limsup[indim] <- extrato$ponto.otimizado[indim] < intervalo.acerto[indim,2];

42

+ } + if(sum(liminf) == ndim && sum(limsup) == ndim){ + acertos.elipsoidal.dc <- acertos.elipsoidal.dc + 1; + itera c~ oes.elipsoidal.dc[acertos.elipsoidal.dc] <- extrato$itera c~ oes; + } + } + return(list( + acertos.gradiente = acertos.gradiente, + media.itera c~ oes.gradiente = mean(itera c~ oes.gradiente), + acertos.newton = acertos.newton, + media.itera c~ oes.newton = mean(itera c~ oes.newton), + acertos.newtonmod = acertos.newtonmod, + media.itera c~ oes.newtonmod = mean(itera c~ oes.newtonmod), + acertos.quasinewton.cp = acertos.quasinewton.cp, + media.itera c~ oes.quasinewton.cp = mean(itera c~ oes.quasinewton.cp), + acertos.quasinewton.dfp = acertos.quasinewton.dfp, + media.itera c~ oes.quasinewton.dfp = mean(itera c~ oes.quasinewton.dfp), + acertos.quasinewton.bfgs = acertos.quasinewton.bfgs, + media.itera c~ oes.quasinewton.bfgs = mean(itera c~ oes.quasinewton.bfgs), + acertos.quasinewton.hb = acertos.quasinewton.hb, + media.itera c~ oes.quasinewton.hb = mean(itera c~ oes.quasinewton.hb), + acertos.elipsoidal = acertos.elipsoidal, + media.itera c~ oes.elipsoidal = mean(itera c~ oes.elipsoidal), + acertos.elipsoidal.deepcut = acertos.elipsoidal.dc, + media.itera c~ oes.elipsoidal.deepcut = mean(itera c~ oes.elipsoidal.dc) + )) + }

43