| Newsgroups |
gmane.comp.gnu.octave.sources |
| Message-ID |
<[email protected]> |
Hi all,
so now OpenOpt 0.35, collection of some local non-smooth and some global
solvers is available
Key features:
new functions: nonSmoothSolve() & ominsearch(), with same syntax as MATLAB
fsolve & fminsearch;
now solver ralg() (non-smooth optimizer, fminsearch() analog, can handle
ill-conditioned problems) can handle all types of linear & non-linear
constraints, as long as their gradients/subgradients:
lb<=x<=ub, A*x<=b, Aeq*x=beq, c(x)<=0, h(x)=0; user-supplied dc/dx, dh/dx
(and ShorEllipsoid() too, however, usually (exception for some small-scale
problems) ralg is much more better)
providing patterns to c, h, f (if no (sub)gradient is provided for c, h, f)
also can greately speedup your code (this is valid for nonSmoothSolve too).
prob.parallel.f=1 turnes on parallel calculation of objFun (sub)gradient via
dfeval() (MDCE, jobmanagers, workers must be properly started). Octave users
must provide func with similar to dfeval syntax in prob.parallel.fun, for
example something like
function y=myDFeval(fun,x)
y = my_dfeval_engine(fun, x, 'jobmanager', 'jobmanager.cherkassy.ua',
'jobmanagerhost', '15.08.19.80', ...);
------------------------------------------------------------------------------------------------------------------------------
prob.parallel.fun = @myDFeval;
prob.parallel.c & prob.parallel.h will be (I hope) in future OpenOpt
version.
+LOTS of minor changes;
graphics:
-new marker (right-pointing triangle), reporting that MaxTime, MaxCPUTime,
MaxIter, MaxFunEvals or etc is exeeded;
(markers in Octave currently are absent)
-graphic output speed is increased.
(some problems in Octave graphics still remain, but it's because of
temporary Octave incompabilities & problems with connecting to gnuplot)
examples: I recomend you starting with Examples/ooexample5.m, ooexample2.m,
ooexample1.m, nonSmoothSolveEx.m. Try also using MATLAB fminsearch in objFun
from examples ooexample2 & ooexample5 (even without any constraints,
patterns and derivatives) - it can't solve but ralg can, it seems to be more
powerfull than adsmax, fminsearchOS, fmins, even commercial nonsmooth
solvers CONDOR & snopt (however, I can't say I tried enough number of
problems). It is based on implementation of Naum Z. Shor r-alg with adaptive
spase transformation. It has only 1 euristic (that speeds convergence up,
but makes algorithm more unstable in particular, very seldom, cases) vs lots
in SolvOpt (use web search) - so sometimes it is slower than SolvOpt but
more stable - I know some examples where SolvOpt can't find optimum but
OpenOpt ralg can, and noone wise versa (at least, for all UC problems -
constraits are implemented in other ways). BTW SolvOpt can't work with
Octave, has unconvinient interface, can't handle equality constraints &
hasn't been upgraded since 2001.
If you know other free solver for MATLAB/Octave or Python, that can solve
fun(x) = @(x) sum(abs(x) .* 1.2 .^ (0:length(x)-1).'); % -> min
(x0=ones(N,1) (or better cos(1:N).'), N=60...75; x_opt = all-zeros)
please inform me, thank you in advance.
BTW for example now you can try
opts = optimset(@fminsearch);
opts.MaxIter = 1e4;
[x fv istop output] = fminsearch(fun, x0,opts);
[x2 fv2 istop2 output2] = ominsearch(fun, x0,opts);
as far as I remember fminsearch can't solve the one even for N=16; the same
thing, of course, to fminunc, fmincon.
NB! ominsearch is just a wrapper for ralg with same syntax as MATLAB
fminsearch (for compability), it can' handle any constraints, derivatives,
patterns, graphic output.
Non-smooth & noisy problems often appear in different engeneer calculations,
for example
fun(x) = x(1)+abs(x(2))+quad('exp(sqrt(x(3)))*abs(x5)', 0, 1),
where quad is obtained numerically with small calculation errors.
See also a comparison nonSmoothSolve vs MATLAB fsolve (in
nonSmoothSolveEx.m.), that failes to solve non-smooth & noisy func cases
even with very small noise; in Octave you should make small changes related
to MATLAB/Octave fsolve other sintax. nonSmoothSolve is based on ralg (by
default, can be changed) & tries to minimize
sum(lambda(i)*abs(objfunval(i)), where lambda after some iterations are
ajusting automatically, untill found x: all coords of objfun(x) are less
than TolFun.
Note!! for solver ralg in some cases starting from infeasible x0 is better
than from feasible. It's due to estimating first Lagrange multipliers lambda
& mu, that initially (if user don't provide them in prob.lambda, prob.mu)
are zeros, and problem can turn to be undounded (for example, fun(x)=c*x);
or it can get very far from x0, yielding huge lagrange multipliers values,
that will lead to unpresize answer (automatic updating of lagrange
multipliers after some iterations is implemented, but I can't state it works
very effective, at least for now). If you can implement a constraint both as
eq or ineq, former is better for cputime (I don't need calculating gradient
when c(x)<=0), but latter is sometimes better for preserving a problem to be
unbounded (or close to unbounded) in several first iterations (as I
mentioned above).
Since ralg is optimized for non-smooth problems, it of course will fail
comparison to fminunc/fmincon when funcs are smooth. The same thing to
nonSmoothSolve vs fsolve.
Global solvers (connected from others GPL sourses & some hand-turning to be
able run in Octave): currently nothing special, "just works". global-local
solver hPSO currently is very slow - it calls lots of ralg in each iter;
anneal - global UC (need x0, maybe, lb-ub limits will be added in future),
buscarnd - needs r0, can't handle lb-ub; GAConstrain - needs lb, ub, can
handle Ax<=b, c(x)<=0 (but I can't state it is done very well).
License: GNU GPL2
(the only restriction that I want to underline: connecting to any packages
with removing "randInfo" field from output struct is not allowed (at least,
without OpenOpt developers permission), it will be treated as removing
information about OpenOpt developers, which is not allowed in terms of GNU
GPL2; the same thing to modifying of randInfo output content).
auto printing of randinfo field can be suppressed via setting
prob.iterPrint<0
Download zip-archive (~200kB) is available in
http://www.mathworks.com/matlabcentral/fileexchange/loadFile.do?objectId=13115&objectType=file
+ please download & replace ooIter.m from
http://www.box.net/public/6bsuq765t4
elseware a bug can appear (in ralg or ShorEllipsoid, when no (sub)gradient
is provided for objFun)
(according to Matlabcentral rules I can't update files more than once per 2
monthes)
INSTALL: add to path recursively
I hope in future reliases MATLAB fmincon equivalent (at least with 1st
derivatives, probably, 2nd will be added in future) & bintprog equivalent
(even more powerfull (based on a GRASP modification of icyb workers Dr.
Shilo & others) than current MATLAB realization (based on branches) ) will
be added.
Probably, future OpenOpt versions will be Python-based (there are some
connecting tools from Python to MATLAB/Octave).
If you'll found OpenOpt usefull & want further OpenOpt development (or
speedup that one; or Python version), please donate.
Leaving a good review at
http://www.mathworks.com/matlabcentral/fileexchange/loadFile.do?objectId=13115&objectType=file
is also very apriciated, in future I could show that link to a someone who
can donate further OpenOpt development.
WBR, Dmitrey
cybernetics instityte of Ukraine National Science Academy, optimization
department
--
View this message in context: http://www.nabble.com/OpenOpt-v0.35-is-reliesed-%28free-MATLAB-Octave-optim-toolbox%29-tf3252760.html#a9042038
Sent from the Octave - Sources mailing list archive at Nabble.com.