Daniel Xavier Wolbert

Técnicas de Otimização de Funções Não-Lineares

Atividade extra classe da

disciplina de Otimização de
Sistemas, do curso de
Engenharia de Controle e
Automação, da Universidade
Federal de Minas Gerais

Belo Horizonte, 17 de junho de 2010.

Introdução
O presente trabalho tem como objetivo apresentar técnicas de busca de mínimos para funções
não-lineares, baseado em uma determinada faixa de tolerância. O valor deste em um
problema de otimização pode ser encontrado, através de uma análise da função para vários
valores, iterativamente. A cada iteração, define-se um vetor direção e o tamanho do “salto”,
de forma que a posição encontrada do vetor XK esteja em um valor abaixo do limite da região
de tolerância do ponto ótimo. Define-se:

𝑋 𝐾+1 = 𝑋 𝐾 + λ𝐾 𝑑𝐾

Sendo λ o tamanho do passo dado, e d o vetor direção. Os métodos a serem abordados aqui
possuem como objetivo definir o tamanho desses saltos a cada iteração,com o mínimo de
iterações possíveis.

O programa a ser desenvolvido obedece ao seguinte algoritmo:

1. Definir a direção de busca, através do seu vetor gradiente.

2. Cercar o intervalo no qual o ponto de mínimo se encontra.
3. Encontrar o valor ótimo de λ , através do método da seção áurea.
4. Cálculo do valor da função após o salto e a direção.
5. Repetir os passos de 1 a 4, até um determinado critério.

Para fins de comparação, serão utilizadas as seguintes funções:

𝑦 = 𝑋12 + 𝑋22 (1)

𝑦 = 10𝑋12 + 5𝑋22 (2)

𝑦 = 15𝑋12 + 7𝑋22 (3)

Com base nesse algoritmo, o seguinte código foi desenvolvido:

Nesse trabalho foram abordados quatro algoritmos:

 Método do gradiente
 Método de Newton
 Método DPF
 Método BFGS
 Método de Broyden

Código-Fonte
%Otimização Não-Linear / Problema Irrestrito
%A função é F(x) = a1x1^2 + a2x2^2
%Algoritmo:
%
%1 - Escolher um ponto inicial X0
%curva de nivel
clear;
%a = [1 1];
%a = [10 5];
a = [15 7];
[xm,ym] = meshgrid([-3:0.1:3],[-3:0.1:3]);
zm = a(1)*xm.^2 + a(2)*ym.^2;
contour(xm,ym,zm,30);

tolerancia = 10^-10;
%Ponto = rand([2,1]);
Ponto = [1; 1] ;
%Marca os pontos aonde a função vai utilizar.
lambdak = 0.001; %Tamanho do passo que vou dar.

%2 - Teste a condição de parada. Se Satisfeita: passo 5

% senão: passo 3

Npassos = 0;
hold;
D = eye(2);
Ponto_Antigo = Ponto;
Ponto = Ponto + lambdak;
while(norm(grad(a,Ponto)) > tolerancia)

%3 - Determine a direção da busca d^k = -gradientef(x^k) ->Método do

% Gradiente.
plot(Ponto(1),Ponto(2),'o');
%dk = -inv(H(a))*grad(Ponto,a); %Método de Newton.
%dk = -grad(Ponto,a); %Método do Gradiente.
dk = -D*grad(Ponto,a); %Direção para o método BGFS e para o método
bfgs

lambdak = cerca(a,Ponto,dk,1,10e-10)
%lambdak = 1;
Ponto_Antigo = Ponto;
Ponto = Ponto + (dk*lambdak);

%D = dfp(Ponto,Ponto_Antigo,D,a); %Mtodo do DFP

%D = bfgs(Ponto,Ponto_Antigo,D,a); %Método do BFGS
D = broyden(Ponto,Ponto_Antigo,D,a) %Método de Broyden

Npassos = Npassos+ 1;

end;

plot(Ponto(1),Ponto(2),'r:');
funcao(a,Ponto)
Npassos

%Boyden
function D = broyden(Ponto,Ponto_Antigo,D,c)
%Considerando alfa = 0.5
A1 = bfgs(Ponto,Ponto_Antigo,D,c);
A2 = dfp(Ponto,Ponto_Antigo,D,c);
D = 0.5*A1 + 0.5*A2;
end

%BFGS
function D1 = bfgs(ponto,ponto_antigo,D,c)
 p = ponto - ponto_antigo;
q = grad(ponto,c)-grad(ponto_antigo,c);
A = 1+(q’*D*q)/(q’*p)*(p*p’)/(p’*q);
B =(p*q’*D+D*q*p’)/(q’*p);
D1 = D + A - B;

end
%Cercar intervalo
function lambda = cerca(p,x,d,s,precisao)

% p -coeficientes da função
% x - ponto da função
% s - Salto
% d - Direção do passo

%s= 0.1

a = 0;
b = s;

ga = funcao(p,x+a*d);
gb = funcao(p,x+b*d);
NCF = 0;

while gb < ga
a = b;
ga = gb;
b = b+s;
gb = funcao(p,x+b*d);
NCF = NCF + 1;
end

if(NCF == 2)
elseif (NCF > 2)
a = a - s;
end

% Reduzir o intervalo de acordo com a previsão

F = 0.62; % seção áurea

lambdaatual = 10;
lambdaanterior = 0;

while (norm(lambdaatual - lambdaanterior) > precisao)

V = b - F*(b - a);
W = a + F*(b - a);

gv = funcao(p,x+V*d);
gw = funcao(p,x+W*d);

if gv<gw
b = W;
gb = gw;
else
a = V;
end

lambdaanterior = lambdaatual;
lambdaatual = (a+b)/2;

end
lambda = lambdaatual;

%DFP
function D1 = dfp(ponto,ponto_antigo,D,c)
p = ponto - ponto_antigo;
q = grad(ponto,c)-grad(ponto_antigo,c);
B = (D*q*q'*D)/(q'*D*q);
A = (p*p')/(p'*q);
D1 = D + A - B;
end

%funcao do problema
function fx = funcao(a,x)
fx = a(1)*x(1)^2 + a(2)*x(2)^2;

%grad
function dy = grad(a,x)

dy = [2*a(1)*x(1) ; 2*a(2)*x(2)];

%matriz hessiana
function z = H(a)
z = [2*a(1) 0;0 2*a(2) ];

Resultados
Método do Gradiente

Função Número de Iterações Valor Final

𝑦 = 𝑋12 + 𝑋22 2 1.3688e-036
𝑦 = 10𝑋12 + 5𝑋22 21 2.7539e-023

𝑦 = 15𝑋12 + 7𝑋22 22 2.9195e-023

 Figura 1 – Pontos Percorridos para o método para as equações (1),(2) e (3), respectivamente

Método de Newton

Função Número de Iterações Valor Final

𝑦 = 𝑋12 + 𝑋22 2 1.1221e-035
𝑦 = 10𝑋12 + 5𝑋22 2 8.4154e-035

𝑦 = 15𝑋12 + 7𝑋22 2 1.2343e-034

 Figura 2 – Pontos Percorridos para o método para as equações (1),(2) e (3), respectivamente

Método Davidon-Fletcher-Powell (DFP)

Função Número de Iterações Valor Final

𝑦 = 𝑋12 + 𝑋22 2 3.9191e-036
𝑦 = 10𝑋12 + 5𝑋22 3 2.8594e-033

𝑦 = 15𝑋12 + 7𝑋22 3 3.6468e-033

 Figura 3 – Pontos Percorridos para o método para as equações (1),(2) e (3), respectivamente

Método de Broyden-Fletcher-Goldfard-Shano (BFGS)

Função Número de Iterações Valor Final

𝑦 = 𝑋12 + 𝑋22 2 1.6542e-035
𝑦 = 10𝑋12 + 5𝑋22 52 2.1929e-022

𝑦 = 15𝑋12 + 7𝑋22 53 1.6154e-022

 Figura 4 – Pontos Percorridos para o método para as equações (1),(2) e (3), respectivamente

Método de Broyden

Função Número de Iterações Valor Final

𝑦 = 𝑋12 + 𝑋22 2 8.6967e-038
𝑦 = 10𝑋12 + 5𝑋22 55 1.4365e-022

𝑦 = 15𝑋12 + 7𝑋22 57 2.9617e-022

 Figura 5 – Pontos Percorridos para o método para as equações (1),(2) e (3), respectivamente

Conclusão
O presente trabalho mostrou que a implementação de solução de problemas não-lineares é simples e demanda um
custo computacional pequeno. Em comparação aos métodos, para equação (3) e (2), ficou claro que os métodos de
Newton e os de DFP foram muito mais eficientes do que os de Boyden, Gradiente e BFGS, deixando claro que a
eficiência do algoritmo de solução depende muito da forma como o vetor de direção e o passo é calculado.