Documente Academic
Documente Profesional
Documente Cultură
Otimizao No-Linear
INTRODUO
Considere o seguinte problema irrestrito: minimizar (x), x Rn Muitos algoritmos de otimizao irrestrita assumem a seguinte estrutura geral: Escolha > 0, xo e faa k = 0 while || f ( x k ) || 1: Encontre dk Rn tal que f ( x k )T d k < 0 2: Determine k := arg min >0 f ( x k + d k ) 3: Faa x k +1 := x k + k d k e k:= k + 1 end x* = xk
Notas
1. No passo 1 determina-se uma direo de descida. A condio f ( x k )T d k < 0 garante que f decresce na direo dk a partir de xk para > 0 2. No passo 2 realizada um busca linear para encontrar o tamanho do passo k que minimiza f na direo dk a partir de xk 3. No passo 3 um novo ponto calculado. O critrio de parada || f ( x k ) ||< (idealmente, || f ( x k ) ||= 0 )
Exemplo
No mtodo do gradiente, se || f ( x k ) || , ento d k := f ( x k ) tal que f ( x k )T d k < 0 e a busca linear assume a forma
k := arg min
k >0
f ( x k f ( x k ))
Existem vrios mtodos para encontrar o valor de k k k := arg min k >0 f ( x f ( x )) , dois deles foram abordados e testados neste trabalho, eles so: o Mtodo da Falsa Posio e o Mtodo da Seo urea.
A esta inclinao chamamos de derivada direcional de f (x ) em relao . Assim sendo, o mtodo de Falsa Posio pode ser resumido nas seguintes etapas: Dado x0 e um critrio de parada , fazer: 1. d = f (x ) ; // direo de descida 2. n = 0; // passo inicial igual a zero 3. dd n = f ( x 0 + n d ) T d // derivada direcional inicial 4. n +1 = 0.1 ; // dando um pequeno passo na direo d 5. dd n +1 = f ( x 0 + n +1 d ) T d ; // encontrando valor da derivada direcional para 1 6. Enquanto |ddn+1 | > faa: dd n +1 ( n +1 n ) ; // calculando valor da variao de 7. = dd n dd n +1 8. n +1 = n + ; // encontrando novo valor de 9. dd n +1 = f ( x 0 + n +1 d ) T d ; // derivada direcional para n+1 10. Fim Se f (x ) for uma funo quadrtica ento existe um derivada direcional dd = 0 de tal forma que a convergncia do mtodo ocorrer em apenas duas iteraes. Alguns resultados podem ser visualizados na prxima seo.
RESULTADOS
Nesta seo, analisamos duas funes e obtemos vrios resultados interessantes. Para a implementao dos algoritmos, bem como para a interpretao grfica foi utilizada a ferramenta MatLab 6.0, em um PC com processador Atlon 2.0Ghz e 256Mb de memria RAM. Funo 1: f ( x1 , x2 ) = x1 + x2
2 2
Como vemos, a funo 1 quadrtica e portanto, independente do ponto x0 que partirmos o mtodo convergir em duas nicas iteraes. Analisando a variao de f (x ) em relao obtemos:
Graficamente, percebemos que para = -1 f (x ) =18, e que quando aumentamos o valor de o valor de f (x ) vai decrescendo at =0.5 onde f (x ) =0, e que a partir da, conforme aumentamos , o valor de f (x ) tambm aumenta. Portanto, baseado nesta anlise, deduzimos que k := arg min >0 f ( x k + d k ) = 0.5. Utilizando o mtodo de falsa posio obtemos os seguintes resultados. Teste 1 2 3 4 5 6 x0 [1 1] [1 1] [1 1] [-1 -1] [-0.5 0.5] [1 -0.5]
xn [0 0] [0 0] [0 0] [0 0] [0 0] [0 0]
f ( xn ) 0 0 0 0 0 0
Iteraes 2 2 2 2 2 2
Como vemos, independente do ponto de partida x0 o mtodo converge em duas iteraes e, como prevamos por meio da anlise grfica, o valor de k := arg min >0 f ( x k + d k ) = 0.5.
Funo 2: f ( x1 , x2 ) = 100( x2 x1 ) 2 + (1 x1 ) 2 {Funo de Rosenbrock) A Funo 2 apresenta uma complexidade bem maior que a funo 1 pois deixa de ser quadrtica e isso faz com que a previsibilidade sobre ela seja menor. O grfico formado pela funo 2 no intervalo [-1 1] :
Como vemos, a funo 2 no quadrtica e, portanto, no podemos prever a quantidade de iteraes bem como o valor de k := arg min >0 f ( x k + d k ) , no entanto, analisando o grfico, percebemos que no ponto x=(1,1) o valor da funo igual a zero. Fica claro, calculando os pontos estacionrios onde f ( x*) = 0 que o ponto x=(1,1) mnimo da funo, portanto, podemos prever que partindo de qualquer ponto x o mtodo de falsa posio nos retornar um novo ponto xn+1 na direo do ponto x*=(1,1). Analisando a variao de f (x ) em relao obtemos:
Como podemos ver, partindo de x=(0,0) para nenhum valor de , f (x ) = 0. O melhor valor de f (x ) aproximadamente igual 0.777, quando aproximadamente igual 0.090. Utilizando o mtodo de falsa posio obtemos os seguintes resultados. Teste 1 2 3 4 5 6 7 8 9 10 x0
xn
f ( xn )
Iteraes 13 16 17 11 6 13 1 4 5 6
[0 0] 10e-1 [0 0] 10e-3 [0 0] 10e-6 [-1 -1] 10e-3 [-0.5 0.5] 10e-3 [1 -0.5] 10e-3 [1 1] 10e-3 [0.99 0.99] 10e-3 [0.99 0.99] 10e-9 [0.99 0.99] 10e-14
0.072968 [0.145936 0.000000] 0.774783 0.080627 [0.161254 0.000000] 0.771110 0.080631 [0.161262 0.000000] 0.771110 0.001564 [0.257184 -0.374535] 19.971568 0.002376 [-0.611677 0.381195] 2.602467 0.001613 [0.032216 -0.016108] 0.966004 0.010000 [1.000000 1.000000] 0.000000 0.001013 [0.993991 0.987994] 0.000036 0.001013 [0.993991 0.987994] 0.000036 0.001013 [0.993991 0.987994] 0.000036
Como vemos, partindo do ponto x0 = (0,0) o valor de tende 0.900 tornando-se mais claro conforme aumentamos o critrio de convergncia, pois quando utilizamos =10e-1, =0.072968 e f (x ) =0.774783 e quando =10e-6, =0.080631 e f (x ) =0.771110 melhorando o valor da funo. Analisando agora a funo f ( x1 , x2 ) = 100( x2 x1 ) 2 + (1 x1 ) 2 notamos que quanto maior o valor de x2 em relao x1 maior ser o resultado e que quanto mais prximos estiverem x1 e x2 melhor ser o valor da funo. Fica evidente na tabela acima que o mtodo busca sempre que possvel reduzir o valor de x2 mesmo que para isso seja necessrio aumentar x1, porm sempre minimizando o valor de f (x ) . Partindo de pontos prximos do mnimo da funo o mtodo melhora o valor da funo lentamente pois o tamanho do passo calculado muito pequeno e portanto f (x ) reduzir muito pouco. Isso explica a razo de que o mtodo do gradiente quando aplicado a funes no-quadrticas com certas caractersticas quando chega prximo ao mnimo da funo tem um rendimento baixo e uma convergncia lenta, pois os passos so muito curtos.
2
ALGORITMO
O algoritmo para Busca Linear do Mtodo da Falsa Posio programado em MatLab 6.0 : % Universidade Estadual de Campinas % Faculdade de Engenharia Eletrica e de Computacao % Nome: Tiago Agostinho de Almeida RA: 025625 % % ------------------------------------------------------------------------% METODO -> FALSA POSIO %-------------------------------------------------------------------------% LEGENDA: % ------------------------------------------------------------------------% BU() = Nome do Metodo = Busca Unidimensional % x1 = coordenada x do ponto x % x2 = coordenada y do ponto x % eps = epsilon, criterio de convergencia da derivada direcional % alfa(k) = tamanho do passo na direcao informada % x(k) = vetor-coluna x formada pelas coordenadas x1 e x2 informadas % G = gradiente da funcao no ponto x(k) % dd(k) = derivada direcional da funcao no ponto x(k) % d = direcao que minimiza a funcao % deltaalfa = alfa(k+1) - alfa(k) % F = valor da funcao no ponto x(k)
% ------------------------------------------------------------------------% Inicio function [x,y,z] = BU(); % Limpando tela e inicializando as variaveis clear; clc; % Fornecendo o ponto inicial e a funcao fprintf('\n'); fprintf('\n*** DADOS INICIAIS ***'); fprintf('\n'); fprintf('\nEscolha uma das funcoes abaixo:'); fprintf('\n[1] - f1 = x1^2 + x2^2 ......................'); fprintf('\n[2] - f2 = 100*(x2-x1^2)^2 + (1-x1)^2 .......'); op = input('\nOpcao numero: '); fprintf('\n'); x1 = input('Informe a coordenada inicial para x1: '); x2 = input('Informe a coordenada inicial para x2: '); eps = input('Informe criterio de parada (epsilon): '); % Dados iniciais x0 = [x1; x2]; % Montando o vetor x com as coordenas informadas alfa0 = 0; % Tamanho do passo inicial alfa1 = 0.01; % Tamanho do passo seguinte % Calculando o valor do gradiente para a funcao escolhida switch op case {1} G = [2*x0(1); 2*x0(2)]; case {2} G = [-400*x0(1)*(x0(2)-(x0(1)^2)) - 2*(1-x0(1)); 200*(x0(2)-(x0(1)^2))]; end d = -G; %Direcao d % Derivada Direcional dd0 = G'*d; % Calculando novo x para alfa = 0.01 x1 = x0 + alfa1*d; % Grandiente para o novo x switch op case {1} G = [2*x1(1); 2*x1(2)]; case {2} G = [-400*x1(1)*(x1(2)-(x1(1)^2)) - 2*(1-x1(1)); 200*(x1(2)-(x1(1)^2))];
end % Derivada direcional para o alfa1 dd1 = G'*d; cont = 1; % Contador de iteracoes % Loop para encontrar o tamanho do passo (alfa1) while abs(dd1) > eps if cont >= 1000 % Solucionando o problema do loop infinito break end deltaalfa = (dd1*(alfa1-alfa0))/(dd0-dd1); % Calculando deltaalfa = alfa2 - alfa1 alfa0 = alfa1; % Atribuindo alfa1 em alfa0 alfa1 = alfa1 + deltaalfa; % Calculando novo tamanho do passo x1 = x0 + alfa1*d; % Calculando novo x % Calculando o Gradiente para o novo x switch op case {1} G = [2*x1(1); 2*x1(2)]; case {2} G = [-400*x1(1)*(x1(2)-(x1(1)^2)) - 2*(1-x1(1)); 200*(x1(2)-(x1(1)^2))]; end dd0 = dd1; % Atribuindo derivada direcional nova em derivada direcional anterior dd1 = G'*d; % Calculando nova derivada direcional % Incrementando contador de iteracoes cont = cont + 1; end % Valor da Funcao switch op case {1} F = x1(1)^2 + x1(2)^2; case {2} F = 100*(x1(2)-x1(1)^2)^2 + (1-x1(1))^2; end % Exibindo os resultados fprintf(1,' \n'); fprintf(1,'*** RESULTADO FINAL ***'); fprintf(1,' \n'); fprintf(1,'%d iteracoes \n',cont); fprintf(1,'Tamanho do passo (alfa1) = %f \n',alfa1); fprintf(1,'Ponto final X(x1,x2) = X(%f,%f) \n',x1(1),x1(2)); fprintf(1,'Valor da Funcao f(x1,x2): %f \n', F); fprintf(1,' \n');
O Mtodo da Seo urea utiliza um esquema de reduo do intervalo de incerteza 1 5 baseado na razo urea. A Razo urea ( r = 0.618 ) era considerada na 2 Antigidade como a mais esttica para os lados de um retngulo. Dados um intervalo de incerteza I =[a,b], um critrio de convergncia e uma funo do tipo f ( ) , o mtodo da Seo urea realiza a reduo do intervalo I a uma taxa de reduo igual a razo urea (r) at que o critrio de convergncia seja satisfeito. Do b'+ a' intervalo restante I=[a,b] o valor de obtido pela relao = . 2 Quando utilizamos um critrio de convergncia pequeno, como 10 6 por exemplo, provavelmente o valor de obtido pelo mtodo de Seo urea ser igual (ou prximo) do valor obtido pelo mtodo de Falsa Posio.
RESULTADOS
O Mtodo da Seo urea foi testado para as duas funes utilizadas para o Mtodo da Falsa Posio: 1 Funo 1 : f ( x1 , x2 ) = x1 + x2
2 2
2 Funo 2 : f ( x1 , x2 ) = 100( x2 x1 ) 2 + (1 x1 ) 2 {Funo de Rosenbrock) Os resultados obtidos para a Funo 1 utilizando o Intervalo I foram: Teste 1 2 3 4 5 6 x0 [1 1] [1 1] [1 1] [-1 -1] [-0.5 0.5] [1 -0.5] I [0 1] [0 1] [0 1] [0 1] [0 1] [0 1]
f ( xn )
Iteraes 1 11 25 25 25 25
No teste n 1, utilizamos um critrio de convergncia relativamente grande e por causa disso o intervalo nem chegou a ser reduzido, e, como sabemos que o mtodo utiliza a b'+ a' metade do intervalo como ( = ), o resultado por mero acaso deu que =0.5, que 2 corresponde ao k := arg min >0 f ( x k + d k ) em apenas uma iterao, porm vlido ressaltar que este resultado s foi obtido por mero acaso, pois foi coincidncia estar localizado exatamente na metade do intervalo inicial. No teste n 2 aumentamos o valor de e notamos que o valor de chegou prximo do valor obtido pelo mtodo da falsa posio. Apertando um pouco mais o critrio de convergncia, como no teste n 3 o mtodo da Seo urea obteve o mesmo valor do obtido pela Falsa Posio. Como a anlise grfica foi realizada antes da implementao, podemos perceber que o mtodo retornou o valor esperado e teve um comportamento adequado. Os testes seguintes provam que partindo de um mesmo ponto inicial e utilizando um critrio de convergncia adequado, o Mtodo de Seo urea encontra um k := arg min >0 f ( x k + d k ) igual ao encontrado pelo Mtodo de Falsa Posio. Fica claro que para funes quadrticas o Mtodo da Falsa Posio converge mais rpido que o Mtodo da Seo urea, pois o nmero de iteraes utilizadas por esta bem maior que as duas iteraes necessrias para a convergncia pelo clculo da derivada direcional. Os resultados obtidos pela Funo 2 utilizando o Intervalo I foram: Teste 1 2 3 4 5 6 7 8 9 10 x0 [0 0] [0 0] [0 0] [-1 -1] [-0.5 0.5] [1 -0.5] [1 1] [0.99 0.99] [0.99 0.99] [0.99 0.99] I [0 1] [0 1] [0 1] [0 1] [0 1] [0 1] [0 1] [0 1] [0 1] [0 1]
0.500000 0.081080 0.080628 0.001562 0.002377 0.001613 0.000005 0.004065 0.001012 0.001013
xn [1.000000 0.000000] [0.162159 0.000000] [0.161257 0.000000] [0.256214 -0.375018] [-0.611733 0.381135] [0.032226 -0.016113] [1.000000 1.000000] [1.006019 0.981951] [0.993988 0.987996] [0.993991 0.987994]
f ( xn ) 100.00000 0.771123 0.771110 19.971652 2.602469 0.966004 0.000000 0.090778 0.000036 0.000036
Iteraes 1 11 25 25 25 25 25 11 25 40
10e-1 10e-3 10e-6 10e-6 10e-6 10e-6 10e-6 10e-3 10e-6 10e-9
Como havamos analisado graficamente, sabemos que partindo do ponto x = [0 0] k := arg min >0 f ( x k + d k ) aproximadamente igual 0.09 e f (x ) aproximadamente igual 0.77. No teste n 1 o resultado obtido foi bastante insatisfatrio pois o valor de utilizado foi muito inadequado, isso fica claro analisando-se os dois testes subseqentes em que reduzimos e conseguimos obter resultados muito prximos daqueles que prevamos e que obtivemos pelo mtodo da falsa posio.
Observamos no teste n 7 que quando partimos do ponto x* = [1 1] o resultado obtido foi satisfatrio, porm o nmero de iteraes utilizadas (i = 25) foi muito alm do nmero utilizado pelo mtodo da Falsa Posio (i = 1). Isso mostra que quando estamos prximo do ponto timo o mtodo da Seo urea tem um desempenho menor que o mtodo da Falsa Posio se utilizarmos o mesmo critrio de convergncia. Isso fica claro nos 3 ltimos testes, no qual partimos de um ponto prximo do timo e aumentamos o valor de gradativamente. Como podemos ver, os dois mtodos apresentaram resultados satisfatrios e muito coincidentes com os quais estamos esperando.
ALGORITMO
O algoritmo para Busca Linear do Mtodo da Seo urea programado em MatLab 6.0 : % Universidade Estadual de Campinas % Faculdade de Engenharia Eletrica e de Computacao % Nome: Tiago Agostinho de Almeida RA: 025625 % % ------------------------------------------------------------------------------% METODO -> BUSCA UNIDIMENSIONAL - SECAO AUREA %-------------------------------------------------------------------------------% LEGENDA: % ------------------------------------------------------------------------------% SAurea() = Nome do Metodo = Secao Aurea % r = razao aurea =~ 0,618 % x1, x2 = ponto inicial x (x1,x2) % I1 = ponto inicial do intervalo I % I2 = ponto final do intervalo I % eps = epsilon, criterio de convergencia da derivada direcional % alfa = razao aurea dada por x1 + (1-r)*(x2-x1) % beta = razao aurea dada por x1 + r*(x2-x1) % xna = valor do novo x para um deslocamento alfa % xnb = valor do novo x para um deslocamento beta % y1 = valor da funcao para xna % y2 = valor da funcao para xnb % F = valor da funcao final obtida pelo metodo % -------------------------------------------------------------------------
% Inicio function result = SAurea(); % Limpando tela e inicializando as variaveis clear; clc; % Fornecendo o ponto inicial e a funcao fprintf('\n'); fprintf('\n*** DADOS INICIAIS ***'); fprintf('\n'); fprintf('\nEscolha uma das funcoes abaixo:'); fprintf('\n[1] - f1 = x1^2 + x2^2 ......................'); fprintf('\n[2] - f2 = 100*(x2-x1^2)^2 + (1-x1)^2 .......'); op = input('\nOpcao numero: '); fprintf('\n'); x1 = input('Informe o ponto x1: '); x2 = input('Informe o ponto x2: '); I1 = input('Informe o ponto inicial do intervalo (a): '); I2 = input('Informe o ponto final do intervalo (b): '); eps = input('Informe criterio de parada (epsilon): '); % Dados iniciais x = [x1;x2]; r = (sqrt(5)-1)/2; I = [I1; I2]; % Montando o vetor x com as coordenas informadas alfa = I1 + (1-r)*(I2-I1); beta = I1 + r*(I2-I1); % Calculando o valor da funcao y1 para alfa e y2 para beta switch op case {1} G1 = [2*x(1);2*x(2)]; %Valor do gradiente no ponto x d1 = -G1; %Direcao de descida xna = x + alfa*d1; %Valor do novo x para deslocamento alfa xnb = x + beta*d1; %Valor do novo x para deslocamento beta y1 = xna(1)^2 + xna(2)^2; %Valor da funcao para x com deslocamento alfa y2 = xnb(1)^2 + xnb(2)^2; %Valor da funcao para x com deslocamento beta case {2} G2 = [-400*x(1)*(x(2)-(x(1)^2)) - 2*(1-x(1)); 200*(x(2)-(x(1)^2))]; %Valor do gradiente no ponto x d2 = -G2; %Direcao de descida xna = x + alfa*d2; %Valor do novo x para deslocamento alfa xnb = x + beta*d2; %Valor do novo x para deslocamento beta y1 = 100*(xna(2)-xna(1)^2)^2 + (1-xna(1))^2; y2 = 100*(xnb(2)-xnb(1)^2)^2 + (1-xnb(1))^2; end
cont = 1; % Contador de iteracoes % Loop para encontrar o tamanho do passo (alfa) while (I2-I1) > eps if cont >= 1000 % Solucionando o problema do loop infinito break end if y1>y2 I1 = alfa; alfa = beta; y1 = y2; beta = I1 + r*(I2-I1); switch op case {1} xnb = x + beta*d1; y2 = xnb(1)^2 + xnb(2)^2; case {2} xnb = x + beta*d2; y2 = 100*(xnb(2)-xnb(1)^2)^2 + (1-xnb(1))^2; end else I2 = beta; beta = alfa; y2 = y1; alfa = I1 + (1-r)*(I2-I1); switch op case {1} xna = x + alfa*d1; y1 = xna(1)^2 + xna(2)^2; case {2} xna = x + alfa*d2; y1 = 100*(xna(2)-xna(1)^2)^2 + (1-xna(1))^2; end end % Incrementando contador de iteracoes cont = cont + 1; end alfa = (I2+I1)/2; % Valor da Funcao switch op case {1} xna = x + alfa*d1; F = xna(1)^2 + xna(2)^2;
case {2} xna = x + alfa*d2; F = 100*(xna(2)-xna(1)^2)^2 + (1-xna(1))^2; end % Exibindo os resultados fprintf(1,' \n'); fprintf(1,'*** RESULTADO FINAL ***'); fprintf(1,' \n'); fprintf(1,'%d iteracoes \n',cont); fprintf(1,'Tamanho do passo (alfa1) = %f \n',alfa); fprintf(1,'Ponto Final X(x1,x2) = X(%f,%f) \n',xna(1),xna(2)); fprintf(1,'Intervalo Final I(I1,I2) = I(%f,%f) \n',I1,I2); fprintf(1,'Valor da Funcao f(x1,x2): %f \n', F); fprintf(1,' \n');