Algoritmo Nelder-Mead

Ana Júlia e Arthur Tarso

Departamento de Estatística
Universidade Federal de Minas Gerais

Outubro 2018
 Contents

1 Introdução 5
1.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 15
3.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,
p+1
" ! #
1 X
c= xi − xworst
p
i=1

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 );

(
−360|x1 |2 − x2 − x22 , x1 ≤ 0
g(x1 , x2 ) =
−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 g0 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:

(t) (t) (t) (t) (t) (t)

V(t) = (x2 − x1 , x3 − x1 , ..., xp+1 − x1 )

e seu correspondente vetor de funções objetivas diferenciadas

(t) (t) (t) (t) (t) (t)

δ (t) = (g(x2 ) − g(x1 ), g(x3 ) − g(x1 ), ..., g(xp+1 ) − g(x1 )),
(t) (t)
onde os p + 1 vértices estão todos ordenados com respeito à qualidade de forma que x1 = xbest .
(t)
Então é possível definir o gradiente do simplex do simplex S (t) como D(S (t) ) = (V(t) )−T δ . Esse
(t)
gradiente do simplex é uma aproximação do verdadeiro valor do gradiente de x1 .
Uma reinicialização orientada ocorre quando em média a melhoria dos vértices é muito pequena. Seja

p+1
1 X (t)
g −(t) = g(xi )
p+1
i=1

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
(t)
situados em eixos coordenados centrados em xbest e com comprimentos reduzidos.
(t+1) (t)
Seja x1 = x1 e

(t+1) (t)
x1 = x1 + βj ej

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:

n o n o
(t)) (t))
(
−d(t) sinal D(Sj−1 , sinal D(Sj−1 6= 0
βj =
0, cc

(t)
onde D(Sj−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

(t) (t)
d(t) = min||x1 − xj ||.

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ção
Para t = 1:
(t) (t)
• Escolha os vértices iniciais x1 , . . . xp+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ção
Ordene os vértices de acordo com seu valor avaliado na função de interesse e nomeie:
(t)
• xbest : maior valor de g(x);
(t)
• xbad : segundo menor valor de g(x);
(t)
• xworst : menor valor de g(x).

3. Orientação (direção)
Calcule:
p+1
" ! #
1 X (t) (t)
c(t) = xi − xworst
p
i=1

4. Reflexão
(t) (t)
Calcule xr = c(t) + αr (c(t) − xworst ).
(t) (t) (t)
Compare g(xr ) com g(xbest ) e g(xbad )
(t) (t) (t) (t)
• Se g(xbest ) ≥ g(xr ) > g(xbad ): aceite xr como novo vértice para iteração t + 1 e descarte
(t)
xworst . Vá para o passo de parada (8).

13
 (t) (t)
• Se g(xr ) > g(xbest ): vá para o passo de expansão (5).
• Caso contrário: vá para o passo de contração (6).

5. Expansão
(t) (t)
Calcule xe = c(t) + αe (xr − c(t) ).
(t) (t)
Compare g(xe ) com g(xbest ).
(t) (t) (t) (t)
• Se g(xe ) > g(xr ): aceite xe como novo vértice para iteração t + 1 e descarte xworst . Vá
para o passo de parada (8).
(t) (t)
• Caso contrário: aceite xr como novo vértice para iteração t + 1 e descarte xworst . Vá para o
passo de parada (8).

6. Contração
(t) (t) (t)
Compare g(xe ) com g(xbad ) e g(xworst ).
(t) (t) (t)
• Se g(xbad ) ≥ g(xr ) > g(xworst ): Contração Externa.
(t) (t)
i Calcule xo = c(t) + αc (xr − c(t) ).
(t) (t) (t) (t)
ii Se g(xo ) ≥ g(xr ): aceite xo como novo vértice para iteração t + 1 e descarte xworst .
Vá para o passo de parada (8).
iii Caso contrário vá para o passo de encolhimento (7).
(t) (t)
• Se g(xworst ) ≥ g(xr ): Contração Interna.
(t) (t)
i Calcule xi = c(t) + αc (xworst − c(t) ).
(t) (t) (t)
ii Se g(xi ) > g(xworst ): aceite xi como novo vértice para iteração t + 1 e descarte
(t)
xworst . Vá para o passo de parada (8).
iii Caso contrário vá para o passo de encolhimento (7).

7. Encolhimento
(t) (t) (t) (t) (t) (t)
Para todo j = 1, . . . p + 1 tal que xj 6= xbest calcule xsj = xbest + αs (xj − xbest ).
(t)
Forme um novo simplex com os vértices xbest e os p novos vértices para iteração t + 1. Vá para o
passo de parada (8).

8. Parada
Verifique o critério de convergência. Se ele não foi atingido, incremente t para t + 1 e retorne ao
(t)
passo de ordenação (2). Caso contrário, xbest ) é 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:

 
 x1 (g(x2 ) − g(x3 )) + x2 (g(x3 ) − g(x1 )) + x3 (g(x1 ) − g(x2 )) 
A =   
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":
p
sin( x2 + y 2 )
g(x, y) = 10 p
x2 + y 2

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
 Bibliography

[1] Givens, G. H., Hoeting, J. A. (2013). Computational Statistics. 2 ed. Wiley, 45-52.

[2] CRAN. R documentation on optim function.

25