Re: looking inside FindMininum
- To: mathgroup at smc.vnet.net
- Subject: [mg29319] Re: [mg29304] looking inside FindMininum
- From: "Mark Harder" <harderm at ucs.orst.edu>
- Date: Wed, 13 Jun 2001 03:10:49 -0400 (EDT)
- Sender: owner-wri-mathgroup at wolfram.com
Johannes,
If I understand you correctly, what you are trying to do is use an
unconstrained minimization procedure with a penalty function to accomplish a
constrained (nonlinear?)minimization. There is a method in the literature,
called Sequential Unconstrained Minimization Technique (SUMT, see various
books on optimization). The algorithm is really quite simple; implemented
with FindMinimum, it looks like this:
1,) lamda=1;
assign del (* 0<del<=1 *)
assign outerTolerance (* stopping criterion in
orm[ new{x,y}-old{x,y} ] *)
2.) minOld=FindMinimum[ f[x,y] + lamda*barrier[x,y], x,y, etc...]
3.) lamda=lamda*del (* decrement the barrier function multiplier
*)
4.) g[x,y]=f[x,y] + lamda*barrier[x,y]
5.) minNew=FindMinimum[ g[x,y], x,y, etc... ]
6.) If[ Abs[ minNew-minOld] >outerTolerance,
Then GoTo 3.)
Else, Stop.
7.) End
With each reiteration of the SUMT loop (steps 3-7), the barrier penalty gets
smaller and the solution vector settles into a local minimum that reflects
the underlying objective function more accurately. I have successfully used
this method in a Fortran program with an IMSL unconstrained nonlinear
routine. Upon reading the Mathematica docs ,it seems you could implement
the outer loop (steps 3-7 ) using NestWhile[], which does much of the work
for you. Perhaps this is less efficient than the method you had in mind,
but I think it will work with FM in its standard form (using FM without
pushing its limits can be enough of a headache; best leave it alone, I
think). Of course, the tolerances in FM should be finer than what you pick
for outerTolerance in SUMT.
-mark harder
-----Original Message-----
From: Johannes Ludsteck <johannes.ludsteck at wiwi.uni-regensburg.de>
To: mathgroup at smc.vnet.net
Subject: [mg29319] [mg29304] looking inside FindMininum
>Dear Mathematica Gurus,
>I would like to minimize a function f[x,y]with
>respect to the arguments (x,y). The special
>problem ist that the simple y = 1-x.x > 0 where x
>is (x1,x2...,xn) must hold.
>I do this by minimizing
>f[x,y] + barrier[1-x.x]
>where barrier is a linear function of 1-x.x and
>grows if y approaches 0 or becomes < 0:
>barrier[x_,z_]:=If[#<z,10(1-#/z),0.0]&[1-x.x];
>I. e. barrier > 0 if 1-x.x < z. Where z is a
>small positive number. z is set to a small number
>when the optimization start, but should approach
>0 in the course of the Optimization routine in
>order to avoid distortions of the search.
>I would like to decrease z after every
>optimization step. But in order to do this I have
>to ask FindMininum for the number of steps.
>Until now I do this by
>z=0.1
>FindMinimum[f[y,x]+barrier[1x.x,z*=decrement],...]
>but this is very unsatisfactory, because z is
>decremented every time when f[]+barrier[] is
>evaluated.
>I would like to adjust z in a more sophisticated
>way. But this is possible only if there is any
>way to get more information out of FindMininum,
>for example number of iterations etc.
>Is there any way to milk FindMiniumum?
>By the way: derivatives of f[y,x] cannot be
>computed. Thus I provide two starting values for
>every x and FindMinimum use a derivative-free
>method.
>
>Thank you and best regards,
> Johannes Ludsteck
>
>
>
><><><><><><><><><><><><><><><><><><>
>Johannes Ludsteck
>Institut fuer Volkswirtschaftslehre
>Universitaet Regensburg
>Universitaetsstrasse 31
>93053 Regensburg
>Tel +49/0941/943-2741
>