Post on 21-Jan-2020
Algoritmo Nelder-Mead
Ana Júlia e Arthur Tarso
Departamento de EstatísticaUniversidade Federal de Minas Gerais
Outubro 2018
Contents
1 Introdução 51.1 Nelder-Mead . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.1.1 O que é o algoritmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.1.2 Simplex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.1.3 Funcionamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.1.4 Critério de parada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.1.5 Falha do método . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.1.6 Reinicialização . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.1.7 Vantagens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.1.8 Desvantagens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2 Algoritmo 13
3 Aplicação 153.1 Caso univariado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.2 Caso multivariado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.2.1 Função Sombreiro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.2.2 Normal Bivariada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4 Exercício 23
Bibliography 25
3
1
Introdução
1.1 Nelder-Mead
1.1.1 O que é o algoritmo
Proposto por John Nelder e Roger Mead em 1965, é um método numérico comumente usado para
encontrar o mínimo ou o máximo de uma função objetiva em um espaço multidimensional. É aplicado em
problemas de otimização não-linear para os quais as derivadas não podem ser encontradas.
Por utilizar o conceito de simplex, também é conhecido como método amoeba ou downhill simplex e
cada iteração é baseada em um simplex de k+1 vértices ordenados pelo valor da função. É um método
de busca direta, pois depende somente das classificações de uma coleção de avaliações da função em
possíveis soluções, enquanto tenta encontrar um ponto superior para a próxima iteração.
A eficiência do método baseia-se na capacidade de adaptar bem as curvaturas das funções. Entretanto
a geometria do problema pode ser moldada em tal ponto que pode não ocorrer a convergência à pontos
estacionários.
1.1.2 Simplex
Em geometria, Simplex é a generalização de um triângulo ou tetaedro para um número arbitrário de
dimensões.Um k-simplex possui k+1 vértices.
Figure 1.1: Exemplo de um 3-simplex ou tetraedro.
5
1.1.3 Funcionamento
A t-ésima iteração do algoritmo de Nelder-Mead se inicia com um conjunto de pontos, os quais representam
possíveis soluções, isto é, aproximações do valor máximo da função. Esses pontos definem os vértices
do simplex no qual o esforço de busca é focado. Uma iteração do algoritmo tem como objetivo mudar a
forma e o tamanho do simplex através da identificação de um candidato para substituir o pior ponto do
conjunto.
Quando x é p-dimensional, p+1 pontos distintos (x1, ...,xp+1) definem um simplex p-dimensional.
Os vértices do simplex podem ser classificados do melhor para o pior de acordo com a classificação de
g(x1),...,g(xp+1)
Figure 1.2: Simplex sobreposto aos contornos de uma função objetiva g para p = 2. O vértice best estápróximo ao ponto ótimo de g. A melhor face do triângulo é o lado contendo c, o centroide.
Para encontrar o valor máximo da função, seja xbest o vértice com com o mair valor da função objetiva
e xworst o pior. Denote o segundo pior vértice do simplex como xbad É possível definir a melhor face
como aquela oposta ao vértice xworst. A melhor face é, portanto, o hiperplano que contém os outros
pontos e seu centróide é a média de todos os outros vértice, ou seja,
c =1
p
[(p+1∑i=1
xi
)− xworst
]
Após identificar o pior, o segundo pior e o melhor vértice, o objetivo será substituir o pior vértice
por um melhor. O algoritmo requer que o novo ponto esteja no raio que se estende de xworst até c,
sendo, portanto, chamado de busca direta. Nesse caso, o novo vértice será movido em direção a melhores
alternativas, que se distanciem do vértice classificado como o pior. Além disso, essa substituição irá
alterar a forma e o tamanho do simplex.
É importante observar que embora a busca direta possa ser promissora, a qualidade do novo vértice
também dependerá da distância desse ponto e do xworst, sendo que essa distância modifica o tamanho do
simplex.
A localização do novo vértice escolhido é baseada no vértice de reflexão xr definido como
xr = c + αr (c− xworst) .
A reflexão requer αr > 0 e geralmente adota-se αr = 1. Embora xr não seja o novo vértice, seu valor
juntamente com c e xworst são utilizados para determinar o novo ponto.
6
De forma geral o algoritmo funciona da seguinte forma, considerando primeiramente a situação em
que g(xr) excede g(xbad). Se g(xr) não excede o valor da função objetiva de xbest, então xr é aceito
como o novo vértice e xworst é descartado. O conjunto de vértices atualizados definem um novo simplex
e uma nova iteração do algoritmo começa. No entanto, se g(xr) > g(xbest), então o vértice refletido é
melhor que o melhor vértice atual, então a busca por uma melhora ainda maior será realizada em direção
a g(xr), o que leva a uma tentativa de expansão. Finalmente, se g(xr) é pior que g(xbad), então uma
tentativa de mitigar esse resultado desfavorável é através da contração de g(xr).
Uma expansão ocorre quando g(xr) excede g(xbest). Um ponto de expansão xe é então definido
como
xe = c + αe (xr − c) ,
onde αe > max(1, αr) e geralmente adota-se αe = 2. Então xe é o ponto ao longo do vetor de busca
direta além de xr. Se g(xe) excede g(xr) então a expansão foi bem sucedida e g(xe) é aceito como o
novo vértice, xworst é descartado e inicia-se uma nova iteração. Se g(xe) não excede g(xr), então xr é o
novo vértice, xworst é descartado e inicia-se uma nova iteração.
Figure 1.3: Cinco possíveis transformações do simplex.
Até então foram avaliados casos, em que xr ou xe são melhores que xbad, o segundo pior vértice.
Quando g(xr) não é maior que g(xbad) uma busca adicional é neessária, pois xr, pode ser um vértice pior,
embora tenha substituído xworst. a estratégia de contração é identificar um vértice final em algum lugar
ao longo da direção de busca entre xworst e xr. Quando esse vértice está entre c e xr, a transformação é
chamada contração externa, caso contrário é chamada contração interna.
A contração externa ocorre quando g(xbad) ≥ g(xr) > g(xworst). O vértice obtido por uma contração
externa é definido como
x0 = c + αc(xr − c)
onde 0 < αc < 1 e adota-se αc = 12 . Se g(x0) ≥ g(xr) então o vértice de contração externa é pelo menos
tão bom quanto o vértice obtido pela reflexão, então x0 é escolhido para substituir xworst. Caso contrário,
tem-se a situação em que xr poderia ser o pior vértice depois de ter substituído xworst. Nesse caso, ao
invés de realizar essa substituição sem sentido, uma transformação de retração é executada conforme será
descrito posteriormente.
Uma contração interna é realizada quando g(xr) ≤ g(xworst), ou seja, quando xr é pior que todos os
vértices do simplex. Nesse caso, um ponto de contração interna é definido como
xi = c + αc(xworst − c)
7
Então se g(xi) ≥ g(xworst), xi é escolhido para substituir xworst. caso contrário, nenhuma substitu-
ição razoável para xworst é identificada.
Quando tudo mais falhar, o simplex é submetido a uma transformação de encolhimento. Nesse caso,
todos os vértices com exceção do melhor são encolhidos em direção do xbest através da transformação do
j-ésimo vértice xj para xsj de acordo com a seguinte expressão
xsj = xbest + αs(xj − xbest),
onde j = 1, ..., p+ 1.
Essa transformação irá focar o simplex próximo ao vértice com maior valor da função objetiva. Na
prática o encolhimento acontece raramente e requer que 0 < αs < 1 e adota-se α = 12 .
Figure 1.4: Maximização de uma complicada função bivariada por meio do algoritmo de Nelder-Mead.
1.1.4 Critério de parada
É necessário verificar dois critérios de convergência para o algoritmo Nelder-Mead:
i Alguma medida de mudança relativa na localização dos vértices do simplex;
ii Verificar se os valores da função objetiva aparentam ter convergido.
Para verificar a mudança na localização dos vértices, observar a mudança do melhor vértice, xbest,
não é uma boa escolha, já que ele pode permanecer inalterado por vários passos até que um outro ponto
seja encontrado para substituí-lo.
Uma opção mais efetiva para monitorar a convergência é observar o volume do simples, ao invés de
qualquer ponto em particular.
8
1.1.5 Falha do método
A falha do método é ilustrada na Figura 1.5, na qual ocorre um colapso do simplex.
Considerando a seguinte função objetiva, para p = 2 e x = (x1, x2);
g(x1, x2) =
{−360|x1|2 − x2 − x22, x1 ≤ 0
−6x21 − x2 − x22, cc
Para os chutes iniciais (0,0),(1,1) e (0.84,-0.59), as iterações produzem simplex para os quais os
melhores vértices nunca mudam, apesar de estarem longe de qualquer extremo. Ainda assim a área do
simplex converge para zero, como observado na Figura 1.5. Nesse caso, a busca direta se torna ortogonal
a g′ de modo que a melhoria em sucessivas iterações convergem para zero.
Figure 1.5: Ilustração de falha do método Nelder-Mead.
1.1.6 Reinicialização
Quando verifica-se a estagnação do algoritmo, uma reinicialização com um simplex diferente pode ser
a solução para o problema, colocando o algoritmo em um diferente e possivelmente numa trajetória
mais produtiva. Alternativamente, a reinicialização orientada é projetada com o objetivo de remodelar o
simplex visando a convergência. Definindo como p x p uma matriz de direções do simplex como:
V(t) = (x(t)2 − x
(t)1 ,x
(t)3 − x
(t)1 , ...,x
(t)p+1 − x
(t)1 )
e seu correspondente vetor de funções objetivas diferenciadas
δ(t) = (g(x(t)2 )− g(x
(t)1 ), g(x
(t)3 )− g(x
(t)1 ), ..., g(x
(t)p+1)− g(x
(t)1 )),
onde os p + 1 vértices estão todos ordenados com respeito à qualidade de forma que x(t)1 = x
(t)best.
Então é possível definir o gradiente do simplex do simplex S(t) como D(S(t)) = (V(t))−Tδ(t)
. Esse
gradiente do simplex é uma aproximação do verdadeiro valor do gradiente de x(t)1 .
Uma reinicialização orientada ocorre quando em média a melhoria dos vértices é muito pequena. Seja
g−(t) =1
p+ 1
p+1∑i=1
g(x(t)i )
9
a média dos valores da função objetiva dos vértices S(t) na iteração t. Define-se um crescimento
suficiente na qualidade do simplex da iteração t para t+ 1, quando
g−(t+1) − g−(t) > ε||D(S(t))||2,
onde ε é um valor pequeno (ex.:0,0001).
Nesse caso, a reinicialização consiste em substituir todos os vértices exceto xbest, com vértices
situados em eixos coordenados centrados em x(t)best e com comprimentos reduzidos.
Seja x(t+1)1 = x
(t)1 e
x(t+1)1 = x
(t)1 + βjej
para j = 2, ..., p+1, onde ej é o vetor unitário p ao longo dos eixos coordenados e βj orienta e dimensiona
os passos da seguinte forma:
βj =
{−d(t)sinal
{D(S
(t))j−1
}, sinal
{D(S
(t))j−1
}6= 0
0, cc
onde D(S(t)j−1, para j = 2, ..., p+ 1 representa a componente correspondente do gradiente S(t) e o fator
escalar d(t) é o comprimento mínimo orientado
d(t) = min||x(t)1 − x
(t)j ||.
A justificativa para a reinicialização orientada é que um novo gradiente do simplex no ponto xbest
deve apontar em uma direção que se aproxima do verdadeiro gradiente da função objetivo, uma vez que o
simplex seja pequeno o suficiente e desde que o gradiente do simplex esteja no octante correto.
1.1.7 Vantagens
Como vantagens da utilização deste método, destacam-se:
• Não é necessário calcular as derivadas da função para fazer a otimização;
• O método é eficiente para um número baixo/moderado de dimensões;
• O método possui uma abordagem robusta, no sentido de que pode ser usado para encontrar o ponto
ótimo de uma vasta gama de funções;
• Pode ser usado para funções descontínuas;
• Robustez para atingir a convergência, mesmo na presença de ruído aleatório,
10
1.1.8 Desvantagens
Como desvantagens da utilização deste método, destacam-se:
• Para problemas de alta dimensionalidade, a eficácia do método é variada, dependendo da natureza
do problema;
• Em alguns casos, o algoritmo pode convergir para pontos que não são de máximo nem mínimo;
• Dificuldade em escolher bons critérios de parada;
• Baixa velocidade de convergência.
11
2
Algoritmo
Em resumo, o algoritmo Nelder-Mead segue os seguintes passos.
1. InicializaçãoPara t = 1:
• Escolha os vértices iniciais x(t)1 , . . . x(t)p+1;
• Escolha os valores dos α’s tais que:
αr > 0,
αe > max(1, αr),
αc ∈ (0, 1),
αs ∈ (0, 1).
Valores padrão são (1, 2, 12 ,12).
2. OrdenaçãoOrdene os vértices de acordo com seu valor avaliado na função de interesse e nomeie:
• x(t)best: maior valor de g(x);
• x(t)bad: segundo menor valor de g(x);
• x(t)worst: menor valor de g(x).
3. Orientação (direção)
Calcule:
c(t) =1
p
[(p+1∑i=1
x(t)i
)− x(t)worst
]
4. ReflexãoCalcule x(t)r = c(t) + αr(c
(t) − x(t)worst).
Compare g(x(t)r ) com g(x
(t)best) e g(x
(t)bad)
• Se g(x(t)best) ≥ g(x
(t)r ) > g(x
(t)bad): aceite x(t)r como novo vértice para iteração t+ 1 e descarte
x(t)worst. Vá para o passo de parada (8).
13
• Se g(x(t)r ) > g(x
(t)best): vá para o passo de expansão (5).
• Caso contrário: vá para o passo de contração (6).
5. ExpansãoCalcule x(t)e = c(t) + αe(x
(t)r − c(t)).
Compare g(x(t)e ) com g(x
(t)best).
• Se g(x(t)e ) > g(x
(t)r ): aceite x(t)e como novo vértice para iteração t+ 1 e descarte x(t)worst. Vá
para o passo de parada (8).
• Caso contrário: aceite x(t)r como novo vértice para iteração t+ 1 e descarte x(t)worst. Vá para o
passo de parada (8).
6. ContraçãoCompare g(x
(t)e ) com g(x
(t)bad) e g(x
(t)worst).
• Se g(x(t)bad) ≥ g(x
(t)r ) > g(x
(t)worst): Contração Externa.
i Calcule x(t)o = c(t) + αc(x(t)r − c(t)).
ii Se g(x(t)o ) ≥ g(x
(t)r ): aceite x(t)o como novo vértice para iteração t+ 1 e descarte x(t)worst.
Vá para o passo de parada (8).
iii Caso contrário vá para o passo de encolhimento (7).
• Se g(x(t)worst) ≥ g(x
(t)r ): Contração Interna.
i Calcule x(t)i = c(t) + αc(x(t)worst − c(t)).
ii Se g(x(t)i ) > g(x
(t)worst): aceite x(t)i como novo vértice para iteração t + 1 e descarte
x(t)worst. Vá para o passo de parada (8).
iii Caso contrário vá para o passo de encolhimento (7).
7. EncolhimentoPara todo j = 1, . . . p+ 1 tal que x(t)j 6= x
(t)best calcule x(t)sj = x
(t)best + αs(x
(t)j − x
(t)best).
Forme um novo simplex com os vértices x(t)best e os p novos vértices para iteração t+ 1. Vá para o
passo de parada (8).
8. ParadaVerifique o critério de convergência. Se ele não foi atingido, incremente t para t+ 1 e retorne ao
passo de ordenação (2). Caso contrário, x(t)best) é dado como o valor que aproxima o maximizador
de g
14
3
Aplicação
Neste topico são apresentadas aplicações da maximização de funções por meio do algoritmo Nelder-Mead
para o caso de uma função univariada e multivariada. Os códigos foram desenvolvidos em R.
3.1 Caso univariado
O método de Nelder-Mead não é confiável para o caso univariado (Fonte: optim, R), mas sua imple-
mentação é justificada pela simplicidade do algoritmo no caso de uma função univariada, para fins de
entendimento do método.
Para o caso univariado foi utilizado um 2-simplex (triângulo), que possui três vértices.
Foram determinados três critérios de convergência:
i Volume do 2-simplex (área de um triângulo), dada por:
A =
∣∣∣∣x1(g(x2)− g(x3)) + x2(g(x3)− g(x1)) + x3(g(x1)− g(x2))
2
∣∣∣∣ii Diferença absoluta entre o melhor e pior vértices avaliados na função de interesse:
|g(xbest)− g(xworst)| ≤ ε
iii Diferença absoluta entre o melhor e pior vértices:
|xbest − xworst| ≤ ε
Abaixo é apresentado o código em R da implementação do modelo.
nelder.mead <- function(x, g){
#1) Initialize
alpha_r = 1
alpha_e = 2
alpha_c = 1/2
alpha_s = 1/2
safe_count = 0
epsilon = 10^(-5)
15
area = 0
while(1==1){
#2) Sort x = c(-1,2,4)
#stopping_step_flag = 0
expansion_step_flag = 0
contraction_step_flag = 0
shrinking_step_flag = 0
x_best = x[which.max(g(x))]
x_bad = x[-c(which.max(g(x)),which.min(g(x)))]
x_worst = x[which.min(g(x))]
#3) Orient
c = (1/3)*(x_best+x_bad - x_worst)
#4) Reflect
x_r = c + alpha_r*(c-x_worst)
if((g(x_best)>=g(x_r))&(g(x_r)>g(x_bad))){
x[which.min(g(x))] = x_r
#stopping_step_flag = 1
}else if(g(x_r)>g(x_best)){
expansion_step_flag = 1
}else{
contraction_step_flag = 1
}
#5) Expansion
if(expansion_step_flag == 1){
x_e = c + alpha_e*(x_r - c)
if(g(x_e)>g(x_r)){
x[which.min(g(x))] = x_e
#stopping_step_flag = 1
}else{
x[which.min(g(x))] = x_r
#stopping_step_flag = 1
}
}
#6) Contraction
if(contraction_step_flag == 1){
#a) Outer Contraction
16
if((g(x_bad)>=g(x_r))&(g(x_r)>g(x_worst))){
x_o = c + alpha_c*(x_r-c)
if(g(x_o)>=g(x_r)){
x[which.min(g(x))] = x_o
#stopping_step_flag = 1
}else{
shrinking_step_flag = 1
}
}
#b) Inner Contraction
if(g(x_worst)>=g(x_r)){
x_i = c + alpha_c*(x_worst-c)
if(g(x_i)>g(x_worst)){
x[which.min(g(x))] = x_i
#stopping_step_flag = 1
}else{
shrinking_step_flag = 1
}
}
}
#7) Shrinking
if(shrinking_step_flag == 1){
x_sb = x_best + alpha_s*(x_bad-x_best)
x_sw = x_best + alpha_s*(x_worst-x_best)
x = c(x_best, x_sb, x_sw)
}
#8) Stopping
safe_count = safe_count+1
area = abs(x[1]*(g(x[2])-g(x[3]))
+ x[2]*(g(x[3])-g(x[1]))
+ x[3]*(g(x[1])-g(x[2])) )/2
if((area <= epsilon)
& (abs(g(x_best)-g(x_worst))<epsilon)
& (abs(max(x)-min(x))<epsilon)){ #Check convergence criteria
return(x_best)
}
if(safe_count>=100){
print("Convergence not achieved")
return(NULL)
17
}
}
}
func <- function(x){
return(dgamma(x,4,2))
}
grid = seq(0,8,0.01)
plot(grid,func(grid),type="l")
inits = sample(grid,3)
#inits = c(0.1,1,0.5)
max = nelder.mead(inits, func)
paste("max = ",round(max,2)," f(max) = ", round(func(max),2))
plot(grid,func(grid),type="l", xlab = "x",
ylab = "g(x)", main = "Nelder-Mead Maximization")
lines(max,func(max),type="p", pch=19, col="red")
abline(h = func(max),col="red")
abline(v = max,col="red")
optim(4,func,method = "Nelder-Mead")
Figure 3.1: Resultado da maximização de uma Γ(4, 2) por meio do algoritmo Nelder-Mead.
3.2 Caso multivariado
Para o caso multivariado, foi utilizada a função optim do R, selecionando o método Nelder-Mead
e fnscale negativo, para que seja feita a maximização. A função optim recebe como parâmetros o
18
vetor pontos iniciais de x, sob os quais o algoritmo encontrará um simplex adequado, e a função a ser
maximizada/minimizada, que deve ser escrita na forma de vetor, e.g. x = [x1, x2, . . . , xn].
3.2.1 Função Sombreiro
O método Nelder-Mead foi utilizado para maximizar a função "Sombreiro":
g(x, y) = 10sin(
√x2 + y2)√
x2 + y2
Figure 3.2: Função "Sombreiro.
Como essa função possui pontos de máximo local, de acordo com os valores iniciais escolhidos um
valor distinto para o ponto de máximo pode ser encontrado pela função optim.
Abaixo é apresentado o código em R para maximização da função.
require(scatterplot3d)
#Set plot points
x = seq(-10, 10, length= 100)
y = x
fr = function(x, y) { r = sqrt(x^2+y^2); 10 * sin(r)/r }
z = outer(x, y, fr)
z[is.na(z)] = 1
#Plot using scatterplot 3d
X = expand.grid(x,y)
x = X[,1]
y = X[,2]
z = c(z)
scatterplot3d(x,y,z,color="lightblue",pch=21,main="3-D Scatter Plot")
#Get maximum for this function
fn = function(x) { r = sqrt(x[1]^2+x[2]^2); 10 * sin(r)/r }
max = optim(c(-2,2), fn, method = "Nelder-Mead",control=list(fnscale=-1))
19
#max = optim(c(-5,-5), fn, method = "Nelder-Mead",control=list(fnscale=-1))
#max = optim(c(-10,10), fn, method = "Nelder-Mead",control=list(fnscale=-1))
max$par
max$value
#Mark maximum on the graph in different color
spl <- scatterplot3d(x,y,z,color="lightblue",pch=21,main="3-D Scatter Plot")
spl$points3d(max$par[1], max$par[2], max$value, pch=17, col="red")
Figure 3.3: par:(−2, 2) Figure 3.4: par:(−10, 10) Figure 3.5: par:(−5,−5)
Figure 3.6: Valores de máximo (triângulo vermelho) para diferentes escolhas de pontos iniciais (par).
3.2.2 Normal Bivariada
O método Nelder-Mead foi utilizado para maximizar a função Normal bivariada.
Abaixo é apresentado o código em R para maximização da função.
require(scatterplot3d)
#Set plot points
x = seq(-3, 3, length= 100)
y = seq(-10, 10, length= 100)
fmvn = function(x, y) {
mux = 0
muy = 2
sigmax = 1
sigmay = 3
rho = 0.3
const = (2*pi*sigmax*sigmay*sqrt(1-rho^2))^-1
const2 = -(2*(1-rho^2))^(-1)
dens = const*exp(const2*(((x-mux)/sigmax)^2
+ ((y-muy)/sigmay)^2 - 2*rho*(x-mux)*(y-muy)/(sigmax*sigmay)))
return(dens)
}
z = outer(x, y, fmvn)
20
z[is.na(z)] = 1
#Plot using scatterplot 3d
X = expand.grid(x,y)
x = X[,1]
y = X[,2]
z = c(z)
scatterplot3d(x,y,z,color="lightblue",pch=21,main="3-D Scatter Plot")
#Get maximum for this function
fmvn = function(x, y) {
mux = 0
muy = 2
sigmax = 1
sigmay = 3
rho = 0.3
const = (2*pi*sigmax*sigmay*sqrt(1-rho^2))^-1
const2 = -(2*(1-rho^2))^(-1)
dens = const*exp(const2*(((x[1]-mux)/sigmax)^2
+ ((x[2]-muy)/sigmay)^2
- 2*rho*(x[1]-mux)*(x[2]-muy)/(sigmax*sigmay)))
return(dens)
}
max = optim(c(-2,2), fmvn, method = "Nelder-Mead",control=list(fnscale=-1))
max$par
max$value
#Mark maximum on the graph in different color
spl <- scatterplot3d(x,y,z,color="lightblue",pch=21,main="3-D Scatter Plot")
spl$points3d(max$par[1], max$par[2], max$value, pch=17, col="red")
Figure 3.7: Resultado da maximização de uma Normal bivariada por meio do algoritmo Nelder-Mead,utilizando função optim do R. Máximo marcado por triângulo vermelho.
21
4
Exercício
Utilize o método de Nelder-Mead para maximizar uma função multivariada de sua escolha, preferencial-
mente multimodal, diferente das já apresentadas neste relatório, e faça um plot com os resultados, para
valores iniciais distintos. Comente os resultados.
Sugestão: utilizar a função optim do R e o pacote scatterplot3d, da forma como foram apresentados
neste relatório.
23