7-1

7. Optimizacin de funciones

Se describen aqu algunos algoritmos bsicos de optimizacin de funciones.


7.1. Mtodo Simplex

El procedimiento se debe a Nelder y Mead. Se trata de un algoritmo simple (de
ah su nombre) que slo requiere la evaluacin de la funcin y no de sus
derivadas. Esto le confiere diversas caractersticas. En principio es un buen
mtodo cuando la funcin a optimizar no es derivable (funciones de
argumentos enteros, por ejemplo) o cuando la derivada no es calculable (o de
clculo muy costoso). Para una funcin analtica el mtodo no es de los ms
eficientes pero permite obtener una respuesta al problema planteado. El
procedimiento tambin se utiliza en el diseo de experimentos: cuando las
variables son parmetros experimentales, se va evaluando la funcin objetivo a
medida que el procedimiento va requiriendo la evaluacin de la funcin en
diversos puntos.

Un simplex es una figura polidrica de n+1 vrtices inmersa en un espacio de
dimensin n. As, por ejemplo, en el plano un tringulo es un simples y en el
espacio tridimensional lo es un tetraedro. Estas figuras, en general, no tienen
porque ser regulares. Los simplex que se deben considerar son los que tienen
rea, volumen o hipervolumen no nulos.

Supondremos que queremos encontrar un mximo de la funcin. A
continuacin se va a exponer el algoritmo de forma sucinta y simple. Ms
informacin se puede encontrar en el libro de Press et al.

Algoritmo bsico simplex para encontrar un punto ptimo (en este caso el
mximo) de una funcin f(x) de n variables:

1. Considerar n+1 puntos del espacio n dimensional. En todos ellos se evala
la funcin f. Estos puntos deben generar un hipervolumen no nulo. Ello se
puede comprobar viendo como el determinante de la matriz formada por los
n-1 vectores posicin de cada punto respecto a uno de ellos que se toma
como origen no es nulo.
2. Del conjunto de puntos, se considera el punto asociado al valor mnimo de f:
Este peor punto se debe sustituir por otro nuevo. La forma habitual de
hacerlo es considerar el centro de masas de los restantes n puntos y hacer
una reflexin del peor punto a travs de ese centro de masas. En esa
reflexin el punto ha recorrido una distancia 2d (siendo d la distancia inicial
entre el punto y el centro de masas). Se evalua la funcin en el nuevo punto
obtenido.
2.1. Si el valor de f es mayor que el del mejor punto, se prueba de
nuevo la reflexin pero avanzando un paso 3d (expansin). Se
elige la opcin que nos de el mejor nuevo punto. Pasar a 3.
7-2
2.2. Si el nuevo punto tiene un valor peor (menor) que el del segundo
peor punto, se hace una reflexin con un paso igual a 1.5d
(contraccin)
2.2.1. Si se contina obteniendo un valor menor que el del
segundo peor punto se hace una contraccin del
simplex (homotecia) con un factor de 0.5 manteniendo
el mejor punto. Se evala la funcin en los nuevos
puntos as obtenidos. Se pasa a 2.
2.2.2. Se pasa a 3.
2.3. Se acepta el nuevo punto calculado en 2.
3. Aplicar el criterio de convergencia: Si la distancia d recorrida es menor que
un cierto valor predeterminado (figura simplex muy diminuta), se acaba el
proceso. En caso contrario se pasa a 2.


7.2. Mtodo de gradiente de Newton

El mtodo de gradiente o de Newton-Raphson es un mtodo analtico bsico y
bastante eficiente. El mtodo se basa en expandir una funcin de n variables
x=(x
1
,x
2
,...,x
n
), f(x), en un punto x
0
en serie de Taylor truncada hasta los
trminos de primer orden:

( ) ( ) ( ) [ ] ( )
0 0 0
x x x x x +
T
f f f .


En esta notacin, el vector gradiente evaluado en el punto x
0
es

( )
( )
( )
( )
0
1
1
0
x x
x
x
x
x
=

=
n
x
f
x
f
x
f
f
M
.


Considerando que el punto x
0
no es estacionario (mximo o mnimo) mientras
que el punto x s que lo es y est lo suficientemente prximo a x
0
(tanto como
para que la aproximacin de hasta primer orden sea suficientemente precisa)
entonces podemos plantear que

( ) 0 = x f
y
( ) ( ) ( ) [ ] ( ) { }
0 0 0
0 x x x x x + =
T
f f f ,


con lo cual

( ) ( ) [ ] ( )
0 0 0
0 x x x x + =
T
f f ,


7-3
El gradiente del vector gradiente es la matriz hesiana, la cual contiene todas las
segundas derivadas evaluadas en el punto x
0
:

( ) [ ] ( )
( ) ( ) ( )
( ) ( ) ( )
( ) ( ) ( )
0
2
2
2
1
2
2
2
2 2
2
1 2
2
1
2
2 1
2
1 1
2
0 0
x x
x x x
x x x
x x x
x H x
=

= =
n n n n
n
n
x x
f
x x
f
x x
f
x x
f
x x
f
x x
f
x x
f
x x
f
x x
f
f
L
M O M M
L
L
.

Para una funcin analtica que se comporte bien, la matriz hesiana es
simtrica:
( ) ( )
i j j i
x x
f
x x
f

=

x x
2 2
i, j.

Continuando, escribimos ( ) ( )( )
0 0 0
0 x x x H x + = f y podemos despejar cual
es el punto x:
( ) [ ] ( )
0
1
0 0
x x H x x f =

.


Hemos de suponer que el punto x as calculado, si no es ya un punto
estacionario, nos da una mejor aproximacin al punto ptimo de la funcin de lo
que era el punto x
0
. El mtodo requiere la inversin de una matriz. En algunas
ocasiones esta matriz se puede simplificar considerando slo los elementos
diagonales. De esta manera su inversin es inmediata.

As pues, el algoritmo iterativo consiste en lo siguiente:

1. Considerar la tolerancia del proceso 0<0.
2. Considerar un punto inicial x
0
.
3. Evaluar el vector gradiente g= ( )
0
x f .
4. Si | g |<, el punto ptimo es x
0
. Terminar.
5. Evaluar ( ) [ ] ( )
0
1
0 0
x x H x x f =

.
6. Redefinir x
0
=x.
7. Ir al paso 3.


7-4
Ejercicios

1. Considerar la funcin f(x,y)=x
2
+xy+y
2
. Partiendo del punto (1,1), aplicar
numricamente el algoritmo de Newton. Comprobar que se llega al punto del
mximo (0,0) en un solo paso. Por qu?

2. Confeccionar programas que codifiquen los algoritmos aqu descritos.

3. Utilizando los algoritmos descritos aqu y partiendo de un punto (o puntos)
arbitrario(s), buscar el mximo de las funciones
2 2
y x z + = y
( )
2 2
y x
e z
+
= , los
cuales se encuentran en el punto (0,0). Por qu para la primera funcin el
mtodo de Newton encuentra la solucin en un nico paso?

4. Qu cambios cabe efectuar en los algoritmos anteriores para poder
localizar mnimos de funciones? Se te ocurre alguna otra estrategia para
mantener los algoritmos sin modificar y an as poder localizar mximos o
mnimos de las funciones?


7-5
Programas

!--------------------------------------------------------------------
! Busqueda de un maximo de una funcion segun el metodo basico simplex
! Ejemplo para la funcion f=exp[-(x**2+y**2)] de dos variables (n=2):
! el simplex es de dimension n+1=3
!--------------------------------------------------------------------
implicit double precision (a-h,o-z)

! Dimensionalidad
parameter (n=2,n1=n+1)

dimension x(n,n1),z(n1),cdm(n),v(n),xnew(n),xnew2(n)
common /counter/ nveces

! Tolerancia para el critero de terminacion
toler=1.0d-3
nveces=0 ! Veces que se evalua la funcion

! Puntos iniciales
x(1,1)=-5.0; x(2,1)=-5.0
x(1,2)=-1.0; x(2,2)=-1.0
x(1,3)= 5.0; x(2,3)=-1.0

! Evalua la funcion en cada punto
do i=1,n1
z(i)=f(x(1,i),x(2,i))
end do

DO ! Proceso iterativo

mi=1 ! Indicaran los puntos minimo y maximo
ma=1 ! (peor y mejor) de los n+1 que se consideran
zmi=z(mi); zma=z(ma)
do i=2,n1
if (z(i)>zma) then
zma=z(i)
ma=i
end if
if (z(i)<zmi) then
zmi=z(i)
mi=i
end if
end do

! Centro de masas
cdm(:)=0.0d0
do i=1,n1
if (i/=mi) then ! excluye el punto del minimo
do j=1,n
cdm(j)=cdm(j)+x(j,i)
end do
end if
end do
cdm(:)=cdm(:)/n

! Calcula vector desplazamiento (de modulo d)
d=0.0d0
do i=1,n
v(i)=cdm(i)-x(i,mi)
d=d+v(i)**2
7-6
end do
d=dsqrt(d)

! Nuevo punto (desplazamiento 2d) y valor de la funcion en el
do i=1,n
xnew(i)=x(i,mi)+2*v(i)
end do
znew=f(xnew(1),xnew(2))

if (znew>z(ma)) then ! Se ha mejorado lo mejor. Prueba 3d

do i=1,n
xnew2(i)=xnew(i)+v(i)
end do
znew2=f(xnew2(1),xnew2(2))
if (znew2>znew) then ! Este nuevo punto es el elegido
znew=znew2
xnew(:)=xnew2(:)
end if
x(:,mi)=xnew(:)
z(mi)=znew

else ! Necesita buscar el segundo peor punto

! mi2 indica el segundo peor punto
do i=1,n1
if (i/=mi .and. i/=ma) then ! Descarta mi y ma
mi2=i
zmi2=z(mi2)
exit
end if
end do
do i=1,n1
if (i/=mi .and. i/=ma) then ! Descarta mi y ma
if (z(i)<zmi2) then
zmi2=z(i)
mi2=i
end if
end if
end do

if (znew<zmi2) then ! Peor que el segundo peor punto
do i=1,n
xnew2(i)=xnew(i)+1.5*v(i) ! Contraccion
end do
znew2=f(xnew2(1),xnew2(2))
if (znew2<zmi2) then ! Continua siendo malo: homotecia
do i=1,n1 ! Recorre los puntos
if (i/=ma) then ! Descarta el mejor
do j=1,n
dist=x(j,i)-x(j,ma)
x(j,i)=x(j,ma)+dist/2 ! Homotecia
end do
z(i)=f(x(1,i),x(2,i))
end if
end do
CYCLE
end if
x(:,mi)=xnew2(:)
z(mi)=znew2

7-7
else
x(:,mi)=xnew(:)
z(mi)=znew
end if

end if

! Criterio de convergencia
if (d<toler) exit ! Final

END DO

write(*,*) " Mejor punto encontrado:"
write(*,*) xnew(:)
write(*,'(" Valor de la funcion:",g14.6)') znew
write(*,'(" La funcion se ha evaluado",i5," veces.")') nveces

END
!--------------------------------------------------------------------
double precision function f(x,y)
implicit double precision (a-h,o-z)
common /counter/ nveces
f=exp(-(x**2+y**2))
nveces=nveces+1
END
!--------------------------------------------------------------------


7-8
!-----------------------------------------------------------------
! Busqueda el punto optimo segun el metodo de Newton
! Solucion particular del problema 1: f=x**2+x*y*y**2
!-----------------------------------------------------------------
implicit double precision (a-h,o-z)
dimension x0(2),x(2),g(2),H(2,2)
dimension Ht(2,2),S(2,2),T(2,2),Ti(2,2),Tit(2,2),Hi(2,2),Si(2,2)

! Punto inicial
x0(1)=1.0d0; x0(2)=1.0d0

DO

! Calcula el gradiente
call gradfun(x0,g)

! Criterio de convergencia
gmod=SUM(g(:)**2)
if (gmod<1.0d-10) then ! Se acaba aqui
write(*,'(" Punto optimo:",2g14.6)') x0(:)
write(*,'(" Modulo del gradiente:",g14.6)') gmod
stop "Programa acabado normalmente."
end if

! Obtiene la matriz Hessiana
call Hess(x0,H)

! INVIERTE HESSIANA. Esta matriz es simetrica
! Se utilizan mas matrices de lo necesario para que
! el codigo sea mas legible

! Matriz simetrica S=HtH definida no negativa
call producto_de_matrices(H,H,S,2,2,2)

! Efectua la descomposicion de Cholesky de S
call Cholesky(S,2,T)

! Inversa de la matriz triangular T: Ti
call inversa_T(T,2,Ti)

! Genera la matriz transpuesta de Ti: Tit
call transpone(Ti,2,2,Tit)

! Calcula la inversa de S: Si=Ti*Tit
call producto_de_matrices(Ti,Tit,Si,2,2,2)

! Calcula la inversa de H: H(-1)=Si*H
call producto_de_matrices(Si,H,Hi,2,2,2)

! Calcula en nuevo punto
call producto_de_matriz_vector(Hi,g,x,2,2) ! El vector Hg
x0(:)=x0(:)-x(:) ! Nuevo punto

END DO


END
!-----------------------------------------------------------------

7-9
!-----------------------------------------------------------------
subroutine gradfun(x,g)
implicit double precision (a-h,o-z)
dimension x(2),g(2)

g(1)= 2*x(1)+x(2) ! df/dx = 2x+y
g(2)= x(1)+2*x(2) ! df/dy = x+2y

END
!-----------------------------------------------------------------
!-----------------------------------------------------------------
subroutine Hess(x,H)
implicit double precision (a-h,o-z)
dimension x(2),H(2,2)

H(1,1)= 2.0d0 ! d2f/dxdx = 2. ! En general, estos terminos
H(1,2)= 1.0d0 ! d2f/dxdy = 1. ! deberian ser funciones
H(2,1)= 1.0d0 ! d2f/dydx = 1. !
H(2,2)= 2.0d0 ! d2f/dydy = 2. !

END
!-----------------------------------------------------------------
!--------------------------------------------------------------------
SUBROUTINE transpone(A,n,m,B)
implicit double precision (A-H,O-Z)
dimension A(n,m),B(m,n)

do i=1,m
do j=1,n
B(i,j)=A(j,i)
end do
end do
END
!--------------------------------------------------------------------
!--------------------------------------------------------------------
SUBROUTINE producto_de_matrices(A,B,C,ma,na,mb)
implicit double precision (A-H,O-Z)
dimension A(ma,na),B(na,mb),C(ma,mb)

do i=1,ma
do j=1,mb
C(i,j)=0.0
do k=1,na
C(i,j)=C(i,j)+A(i,k)*B(k,j)
end do
end do
end do
END
!--------------------------------------------------------------------
!--------------------------------------------------------------------
SUBROUTINE producto_de_matriz_vector(A,u,v,n,m)
implicit double precision (A-H,O-Z)
dimension A(n,m),u(n),v(n)
do i=1,n
v(i)=0.0
do j=1,m
v(i)=v(i)+A(i,j)*u(j)
end do
end do
END
!--------------------------------------------------------------------
7-10
!--------------------------------------------------------------------
subroutine Cholesky(S,n,T)
implicit double precision (a-h,o-z)
dimension S(n,n),T(n,n)

! Define el triangulo inferior con ceros
do i=1,n
do j=1,i-1
T(i,j)=0.0
end do
end do

! Descomposicion de Cholesky
do i=1,n
sum=0.0
do k=1,i-1
sum=sum+t(k,i)**2
end do
t(i,i)=dsqrt(s(i,i)-sum)
do j=i+1,n
sum=0.0
do k=1,i-1
sum=sum+t(k,i)*t(k,j)
end do
t(i,j)=(s(i,j)-sum)/t(i,i)
end do
end do

END
!--------------------------------------------------------------------
!--------------------------------------------------------------------
subroutine inversa_T(T,n,Ti)
implicit double precision (a-h,o-z)
dimension T(n,n),Ti(n,n)

! Define el triangulo inferior con ceros
do i=1,n
do j=1,i-1
Ti(i,j)=0.0
end do
end do

! Inversa de la matriz triangular superior
do L=0,n-1
do i=1,n-L
if (L.eq.0) then
Ti(i,i)=1.0d0/t(i,i)
else
iL=i+L
sum=0.0d0
do k=i+1,iL
sum=sum+t(i,k)*ti(k,iL)
end do
ti(i,iL)=-sum/t(i,i)
end if
end do
end do
END
!--------------------------------------------------------------


7-11
Cdigo que debe cambiarse para buscar el punto ptimo de la funcin
( )
2 2
y x
e z
+
= . Se trata de las funciones de clculo del gradiente y la hessiana:
gradfun() y Hess().


!-----------------------------------------------------------------
! Busqueda el punto optimo segun el metodo de Newton
! Solucion particular para la funcion f=exp[-(x**2+y**2)]
!-----------------------------------------------------------------
!-----------------------------------------------------------------
subroutine gradfun(x,g)
implicit double precision (a-h,o-z)
dimension x(2),g(2)

expo=dexp(-(x(1)**2+x(2)**2))

g(1)= -2*x(1)*expo ! df/dx = -2*x*expo
g(2)= -2*x(2)*expo ! df/dy = -2*y*expo

END
!-----------------------------------------------------------------
!-----------------------------------------------------------------
subroutine Hess(x,H)
implicit double precision (a-h,o-z)
dimension x(2),H(2,2)

expo=dexp(-(x(1)**2+x(2)**2))

H(1,1)= 2*expo*(2*x(1)**2-1.0d0) ! d2f/dxdx = 2*expo*(2x**2-1)
H(1,2)= -4*x(1)*x(2)*expo ! d2f/dxdy = -4xy*expo
H(2,1)= H(1,2) ! Simetrica
H(2,2)= 2*expo*(2*x(2)**2-1.0d0) ! d2f/dydy = 2*expo*(2y**2-1)

END
!-----------------------------------------------------------------