curso_M9.doc

Introducción a Matlab, un enfoque a la simulación y visualización dinámica.

9 Toolbox de Optimización

El toolbox de optimización, es una colección de rutinas de computación numérica, orientadas a la resolución de diversos problemas de costo.

1 Introducción teórica

En esta introducción abordaremos los aspectos teóricos de la optimización basada en gradiente, es decir, de aquellos algoritmos de optimización, que realizan la búsqueda del mínimo costo, según la dirección del gradiente.

El problema consiste en:

,

donde x es un vector n-dimensional y F es una función de costo escalar.

Para minimizar este costo, los algoritmos basados en gradiente, determinan la dirección para la cual la función F tiene una disminución en su valor. Por lo anterior, es común que el resultado de la optimización sea local al punto de inicio de la búsqueda. La adaptación del argumento es:

donde es la ganancia de la dirección del gradiente d y k es el intante de adaptación o iteración sobre la línea de búsqueda. Tal dirección puede estar dada por ejemplo por:

Descenso rápido:

Gradiente conjugado: ,

Newton Raphson:

donde H es la matriz Hessiana, y que de su aproximación iterativa de su inversa proviene el algoritmo denominado BFGS quasi Newton, entre otras variada versiones.

Ejemplo: Descenso rápido.

Escuela de Ingeniería Civil, Universidad del Bio-Bio, Septiembre del 2000

117


Consideremos la siguiente función de costo:

que es equivalente al siguiente sistema:

y utilicemos el algoritmo de descenso rápido, con alguna modificación.

%descenso rápidoclear all;close all;

%gráfico de la función de costofigure(1)x=linspace(-3, 3, 25);y=linspace(-2, 2, 25);[X,Y]=meshgrid(x,y);Z=X.^2+ X.*Y + Y.^2 - X + Y;mesh(X, Y, Z);view([-20, 25]); set(gca, 'box', 'on');axis('tight')

%Condición Inicialx0 = -3; y0 = 1;n=7;p=zeros(n, 2);p(1,1) = x0; p(1,2) = y0;t= p(1, :)';

%BusquedaA = [2 1; 1 2];B = [-1; 1];c_l = 1/2 * t'* A* t + B'*t;

for i = 2:n,g = A*t+B;alpha = g'*g/(g'*A*g);p(i,:)=p(i-1,:)-alpha*g';t = p(i,:)';c_l = [c_l; 1/2 * t'*A*t+B'*t];

end

%figura de contornosfigure(2)x=linspace(-3, 3, 100);y=linspace(-2, 2, 100);[X,Y]=meshgrid(x,y);Z=X.^2 + X.*Y + Y.^2 - X + Y;contour(X, Y, Z, c_l);hold on;plot(x0, y0, '*');flecha(p(:, 1), p(:, 2));hold off;axis image;

function h = flecha(x, y, s, style)

if nargin <= 2, s = 0.2; endif nargin <= 3, style = '-'; end


118


X = [0 1 1-s 1 1-s].';Y = [0 0 s/2 0 -s/2].';arrow = X + Y.*sqrt(-1);

z = x + y*sqrt(-1);a = arrow*diff(z).' + ... ones(5,1)*z(1:length(z)-1).';h = plot(real(a), imag(a), style);

Este programa comienza graficando la función de costo: Z=X.^2+ X.*Y + Y.^2 - X + Y;

Luego se define la condición inicial de búsqueda [x0, y0], y el vector p que almacena en forma iterativa cada variable optimizada.

Para iniciar la búsqueda, se crean las matrices A y B, y la superficie c_l para cada instante de optimización. Así se ejecuta un ciclo de n=7 puntos de análisis, donde la dirección o gradiente opuesto g y ganancia adaptiva es alpha.

Sólo para el aspecto gráfico, se utiliza la función flecha, que dependiendo del tipo de argumentos, genera un vector complejo, que parte del punto óptimo anterior. Sólo se dibujan 5 flechas.

Ejemplo: Descenso rápido, mínimo local.

Consideremos la siguiente función de costo:


119


o superficie bimodal, con a=1.5, b=-1, c=-1 d=1.5. Determinemos las variables x, y, tal que

, a partir de dos diferentes condiciones iniciales.

%Función de costo a analizar, 2 valles%suma de dos costosx=-3:.2:3;y=-3:.2:3;[X,Y]=meshgrid(x,y);

%1º costoa = 1.5; b = -1; z1 = (1 + 2*(X-a).^2 +(Y-b).^2).^(-1);

% 2º costoc = -1; d = 1.5; z2 = (1 + (X-c).^2 +(Y-d).^2).^(-1);

%costo totalZ = -( z1 + 0.6*z2);figure(1); mesh(X, Y, Z);view([-15, 30]); box on; axis('tight')

%Busqueda del mínimofigure(2)contour(X, Y, Z, 8);axis image; hold on;cen=[a b c d];

%primera condición inicialx0 = 2; y0 = 3;n = 301;alpha = 0.02;p = zeros(n, 2);p(1,1) = x0; p(1,2) = y0;

for i = 2:leng,x = p(i-1,1);

y = p(i-1,2); g=grad_eje(x,y,cen); p(i,:)=p(i-1,:)-alpha*g/norm(g);end

plot(x0, y0, '*');plot(p(n, 1), p(n, 2), 'o');n_p = p(1:10:n, :);flecha(n_p(:,1), n_p(:,2), 0.6);

%Segunda condición inicialx0 = 2.5; y0 = 3;n = 301;alpha = 0.02;p = zeros(n, 2);p(1,1) = x0; p(1,2) = y0;

for i = 2:n,x = p(i-1,1);y = p(i-1,2);

g=grad_eje(x,y,cen); p(i,:)=p(i-1,:)-alpha*g/norm(g);end

plot(x0, y0, '*');plot(p(n, 1), p(n, 2), 'o');n_p = p(1:10:n, :);flecha(n_p(:,1), n_p(:,2), 0.6);

%gradiente del costo de %función bimodal

function delta=grad_eje(x,y,cen)


120


%centrosa=cen(1);b=cen(2);c=cen(3);d=cen(4);

%gradientesdz1_dx = -4*(x-a)/(1 + 2*(x-a)^2 + (y-b)^2)^2;dz1_dy = -2*(y-b)/(1 + 2*(x-a)^2 + (y-b)^2)^2;

dz2_dx = -2*(x-c)/(1 + (x-c)^2 +(y-d)^2)^2;dz2_dy = -2*(y-d)/(1 + (x-c)^2 +(y-d)^2)^2;

%vector gradiente delta = -[dz1_dx + 0.6*dz2_dx, dz1_dy + 0.6*dz2_dy];

2 Problemas de Optimización y algoritmos de Solución A continuación se indican los problemas de optimización y el nombre del algoritmo con que pueden ser resueltos.


121



122


3 Algoritmos de escala media

Estos algoritmos tienen como estrategia, la búsqueda sobre trayectorias de línea, del mínimo costo de un determinado problema. Entre estos se encuentran los algotimos: Nelder-Mead Simplex, BFGS quasi-Newton, Gauus-Newton y Levenberg-marquardt.

La función objetivo o índice de costo a analizar, como se indicó en la sección de ejemplos, es:

cuya gráfica es la siguiente:


123


%gráfica de la función de costoclose all; clear all;

v1=linspace(0,3,15);v2=linspace(-10,5,15);

[X,Y]=meshgrid(v1,v2);

f=exp(X).*(4*X.^2 + 2*Y.^2 + ... 4*X.*Y + 2*Y + 1);

figure(1)surf(X,Y,f);

colormap jet; shading flatbox on; axis('tight');

figure(2)contour(X,Y,f,30);

3.1 Minimización sin restricciones

Considere el problema de costo señalado, en el conjunto de valores [x1, x2] :

Paso 1. Crear un archivo con el nombre objfun.function f=objfun(x)f=exp(x(1))*(4*x(1)^2+2*x(2)^2+4*x(1)*x(2)+2*x(2)+1);

Paso 2. Utilizar algún comando que permita encontrar el mínimo de la función.» xo=[-1,1]; %punto de partida» options=optimset('LargeScale','off');» x=fminunc('objfun',xo,options) x = 0.5000 -1.0000

Aquí destacan dos elementos. Primero se dice que el problema de optimización de es media escala, es decir, 'LargeScale'= ='off'. Segundo, el algoritmo de optimización seleccionado es fminunc, es decir, minimización sin restricciones como se indica en la primera tabla.

3.2 Minimización con restricciones


124



sujeto a las restricciones

Debido a que ninguna de las restricciones es lineal, estas no se pueden pasar directamente como argumento a la función fmincon, en vez de eso se debe crear otro archivo con el nombre confun.m. Además se deben re escribir las restricciones según la forma c(x)0:

Paso 1. Escribir un archivo para las restriccionesfunction [c, ceq]=confun(x)%restriciones de desigualdades nolineales c=[1.5+ x(1)*x(2)-x(1)-x(2); -x(1)*x(2)-10];%restricciones de igualdades nolinealesceq=[ ];

Paso 2. Ejecutar en línea de comando o en un archivo.m:%solución del problema con restriccionesxo=[-1 1];options=optimset('LargeScale', 'off');[x,fval]=fmincon('objfun',xo,[], [], [], ... [], [], [], 'confun', options);

»Optimization terminated successfully: Search direction less than 2*options.TolX and maximum constraint violation is less than options.TolConActive Constraints: 1 2

» xx = -9.5474 1.0474» fvalfval = 0.0236» [c,ceq]=confun(x) c = 1.0e-014 * 0.1110 -0.1776ceq = [ ]

En este ejemplo se utilizó la función fminco, que permite incorporar restricciones de igualdad y desigualdad.

Tales restriciones se establecen mediante la simple incorporación de confun (escrita en un determinado formato) en el argumento de la función fminco.

3.3 Minimización con restricciones y límites



125


sujeto a las restricciones

con x1 0 y x2 0

Para restringir los valores de x , lb x ub, utilice el siguiente comando:

» xo=[-1,1]; %punto de partida» lb=[0 0]; %limite inferior» ub=[ ]; %sin limite superior» options=optimset('LargeScale','off');» [x,fval]=fmincon('objfun', xo, [ ],[ ],[ ],[ ], lb, ub, 'confun', options);» f=objfun(x) %evalua la funcion ff = 8.5000» [c,ceq]=confun(x) %evalua las restriccionesc = -0.0000 -10.0000ceq = [ ]

Para establecer las siguientes restricciones x1 10 y 0 x2 se utiliza el comando:lb=[-inf 0];ub=[10 inf];

3.4 Minimización con restricciones de igualdad


sujeto a las restricciones:

Paso 1. Escribir un archivo para las restriccionesfunction [c, ceq]=confuneq(x)%restriciones de desigualdades nolineales c=-x(1)*x(2)-10; %-x1*x2-10<=0

[x,fval]=fmincon('objfun',xo,[],[],[],[],[],[],...'confuneq',options);x = -0.7528 0.4331

» f=objfun(x) %evalua la funcion f


126


%restricciones de igualdades nolinealesceq=x(1)^2+X(2)-1; %x1^2+x2-1=0

Paso 2.» xo=[-1,1]; %punto de partida» options=optimset('LargeScale','off');

f = 1.5093

» [c,ceq]=confuneq(x) %evalua restriccionesc = -9.6738ceq = 4.0672e-010

3.5 Detalles en la formulación

Todos los algoritmos de optimización encuentran el mínimo de una función f. Luego para maximizar una función de costo el argumento debe ser –f.

Todos los algoritmos de optimización considera que la restricción es C(x) 0. Luego para plantear la cota C(x)b, solo es necesario escribir -C(x) + b 0 para quedar en el formato estándar.

Una función objetivo puede depender de diferentes parámetros (P1,P2, ....), que por cierto, modifican el problema de optimización. Lo anterior es establecido de la siguiente manera:

F=objfun(x,P1,P2,...) [x,fval] = fsolve( ‘objfun’,x0,options,P1,P2, ....)

close all; clear all;

%gráfica de la funciónx=0:0.1:6;for k=0:0.1:1; plot(x,ellipj(x,k)); hold on;end;

%soluciónm=0.5;x0=3;options=optimset('Display', 'off');x=fsolve('ellipj',x0,options,m);

plot(x,ellipj(x,m),'o');plot([0 x],[0 0],'r--');plot([x x],[-1 ellipj(x,m)],'r- -‘);

3.6 Optimización multiobjetivo

En esta parte, abordaremos el problema de optimización relacionado a mas de una función de costo, es decir, multiobjetivo. Lo anterior se ejemplifica con un problema de control de procesos.

Ejemplo:


127


En este ejemplo se utiliza la rutina de simulink optsim.mdl.

» optsimDone initializing optsim.

El modelo de la planta corresponde a un sistema de tercer orden sub-amortiguado, donde la acción del actuador esta limitada tanto en valor instantáneo como en pendiente ( u y u ). Así, u solo ingresa al sistema en valores [-2, 2] y con pendiente u menor a 0.8 unidades/segundo.

Para conocer la dinámica del sistema, obtenemos su respuesta en lazo abierto, es decir, sin la acción del controlador PID, para excitación unitaria. Como se observa, existe oscilación y ganancia no unitaria.

En general, se exige que tal respuesta no posee oscilación o que tenga mínimo error frente al seguimiento de una referencia.

Lo anterior se puede traducir en minimizar el error en cada instante de evolución del sistema, entre la referencia unitaria (Step) y la salida de éste (Out). Tal objetivo es múltiple, pues en este caso, es para todo instante de temporal.

Para cumplir con tal objetivo se incorpora la estructura PID o controlador Proporcional-Integral-Derivativo, que posee los parámetros Kp, Ki, Kd respectivamente, y que debemos optimizar.

Lo anterior se realiza de la siguiente forma:

Cree los siguientes programas:

function F = sim_iter(pid,a1,a2)

%variables a optimizarKp = pid(1);Ki = pid(2);

%Opciones de optimizaciónoptions=optimset('LargeScale', 'off',... 'Display', 'iter', ... 'TolX', 0.001, 'TolFun', 0.001);

%Optimización de parámetros


128


Kd = pid(3);

%Simulaciónopt = simset('solver','ode5',... 'SrcWorkspace','Current');[tout,xout,yout] = sim('optsim',[0 100],opt);F = yout-1;

%Optimización multiobjetivo%Cargo diagrama simulink a simularoptsim

%Inicialización de parámetrospid0=[0.63, 0.0504, 1.9688];a1=3; a2=43;

pid=lsqnonlin('sim_iter', pid0, [ ], [ ],... options, a1, a2)Kp=pid(1);Ki=pid(2);Kd=pid(3);

» opt_multipid = 2.9108 0.1443 12.8161

Para construir el programa anterior, primero se crea la función sim_iter, que define los parámetros de simulación como ode5 (algoritmo de la ecuación diferencial), [0 100] (tiempo de simulación), F (error de seguimiento), etc. Luego se crea el programa madre con los parámetros iniciales pid0, y que invoca la función lsqnonlin, u optimización no lineal por mínimos cuadrados. Éste a su vez utiliza sim_iter, para optimizar el PID por una serie de pruebas sobre el error cuadrático.


129

curso_M9.doc

Documents

Transcript of curso_M9.doc