MaplePrimes - answers and comments on Question, Help with an Optimization Problem using NLPSolve

source

acer — Thu, 06 Aug 2009 07:20:27 Z

Could you post the actual code, or upload a worksheet for that to this site?

acer

Actual code

petrivka — Thu, 06 Aug 2009 08:31:04 Z

Sorry, I probably should have just posted this in the beginning.

> restart;

> with(plots);

> with(LinearAlgebra);

> with(ArrayTools);

# These data are from earlier calculations which are rather time consuming

> A := ImportVector(ROMA); Pe := ImportVector(ROMPe); B := ImportMatrix(ROMB); Phi := ImportMatrix(ROMPhi); beta := ImportVector(ROMBeta); N := ImportVector(ROMN); Y := ImportVector(ROMY); ypos := ImportVector(ROMypos); timestep := ImportVector(ROMtimestep);

> na := Size(A, 1); n := Size(Phi, 2); nn := Size(Phi, 1); nPe := Size(Pe, 1); nypos := Size(ypos, 1); ntimestep := Size(timestep, 1);

# K contains parameter values on which the reduced order model is based

> K := Matrix(1 .. n, 1 .. 1); ii := 1; for i to na do for j to nPe do K[ii] := A[i]; ii := ii+1 end do end do;

> K1 := Matrix(1 .. n, 1 .. 1); ii := 1; for i to na do for j to nPe do K1[ii] := Pe[j]; ii := ii+1 end do end do; > K := Concatenate(2, K, K1);

# F contains an interpolation for any parameters within the range I specified in vectors A and Pe

> F := Matrix(n, datatype = float[8]); for i to n do for j to n do F[i, j] := evalf(1/sqrt(((K[i, 1]-K[j, 1])/A[na])^2+((K[i, 2]-K[j, 2])/Pe[nPe])^2+1)) end do end do;

> UF, SigF, VFt := SingularValues(F, output = ['U', 'S', 'Vt']); > SF := Vector(n); for i to n do SF[i] := 1/SigF[i] end do;

> SF := DiagonalMatrix(SF, n, n);

> Fpsinv := VFt^%T.SF.UF^%T;

> C := B.Fpsinv;

> Nodes := ImportVector(NodesTemp);

# f contains the interpolation for a specific case (in this case, the parameters from which the dataset "Nodes" is calculated)--Kguess is a 2 element vector containing these unknown parameters

> f := Vector(n); for i to n do f[i] := evalf(1/sqrt(((Kguess[1]-K[i, 1])/A[na])^2+((Kguess[2]-K[i, 2])/Pe[nPe])^2+1)) end do;

> ROM := evalf(Phi.C.f); > ObjectiveFunction := Vector(nn); for i to nn do ObjectiveFunction[i] := evalf((Nodes[i]-ROM[i])/Nodes[i]) end do;

> p := proc (Kguess) evalf(add(ObjectiveFunction[i], i = 1 .. nn)/nn) end proc;

> Optimization[NLPSolve](2, p, assume = nonnegative);

Error, (in Optimization:-NLPSolve) non-numeric result encountered

Let me know if there's some newbish mistake that I've made. :)

Some Progress

petrivka — Thu, 06 Aug 2009 21:03:43 Z

Acer,

You're right about the procedure problem. I was trying to follow the examples in the help files as closely as I could, and that led to doing things in a more complicated way than necessary. So, I tried to put the objective function directly into NLPSolve as you suggested, along with the constraint that the objective function should not exceed 0.05, and this is the result:

> Optimization:-NLPSolve(add(ObjectiveFunction[i], i = 1 .. nn)/nn, add(ObjectiveFunction[i], i = 1 .. nn)/nn <= 0.5e-1, assume = nonnegative);
Error, (in Optimization:-NLPSolve) unexpected parameters: Lots of stuff containing Kguess[1] and Kguess[2]

I can't seem to convince NLPSolve that Kguess[1] and Kguess[2] are the parameters to be expected, and that they are the variables to be changed to meet the constraint I specified. I even tried constructing the matrix ROM within NLPSolve from Phi, C, and f, and I get the same result, except with a much longer computation time before the error.

Sorry if this problem seems elementary, but I do appreciate your help in resolving this issue.

comments

pagan — Thu, 06 Aug 2009 23:35:00 Z

A few minor comments on efficiency:

Rather than pass the very same add() invocation in two different arguments to NLPSolve, you might try assigning the result of the add() to a variable beforehand, and then passing that assigned variable. (add does not have option remember, AFAIK, so it is unnecessary duplication to have the same addition get computed more than once.)

This next may only matter if your numeric Matrices are very large. Take the Phi.C.f computation, and look at the number of arithmetic operations done. If Phi and C are Matrices and f is a Vector then if can make a measurable difference in performance if you compute Phi.(C.f) instead of (Phi.C).f.

Thank you both for your help

petrivka — Fri, 07 Aug 2009 00:24:42 Z

Thank you both for your help so far. That was a good call, pagan, on the unnecessary computations I was introducing. It looks like I'm getting closer to actually solving for the variables Kguess[1] and Kguess[2], but I'm running into this new issue, as follows:

> errorfunc := Vector(nn); for i to nn do errorfunc[i] := evalf((Nodes[i]-ROM[i])/Nodes[i]) end do;
> ObjectiveFunction := add(errorfunc[i], i = 1 .. nn)/nn;
> Optimization:-NLPSolve(ObjectiveFunction, {ObjectiveFunction >= -.20, ObjectiveFunction <= .20});

Error, (in Optimization:-NLPSolve) no improved point could be found

Now, I know what the values of Kguess[1] and Kguess[2] should be, and when I input these values manually into the vector f and execute the ObjectiveFunction, I get a value of 0.15, which should satisfy the constraints that I had added to NLPSolve.

Also, I tried adding in bounds for Kguess[1] and Kguess[2] with the following code:

> bl := <A[1], Pe[1]>;
> bu := <A[na], Pe[nPe]>;
> Optimization:-NLPSolve(ObjectiveFunction, [ObjectiveFunction <= .20, ObjectiveFunction >= -.20], [bl, bu]);
Error, (in Optimization:-NLPSolve) unexpected parameters: [Vector(2, {(1) = 1/5, (2) = 3000}), Vector(2, {(1) = 2, (2) = 30000})]

Thank you for your patience and assistance!

ah

acer — Thu, 06 Aug 2009 10:36:13 Z

I see. The problem is in the creation of procedure p.

Consider the following example. Here, the formal parameter x of procedure p is not the same as the x in F.

> F := x:
> p := proc(x) F; end proc:
> p(1);
                                       x
> x:=17:
> p(1);
                                      17

Sometimes, a way to get the intended effect is to use unapply to create the procedure. But for your code you'd want to somehow "unapply" w.r.t the Kguess[i] so that the formal parameter was Kguess (to be passed as a Vector). Which is awkward. Another way might be to create the proc with the add call, etc, in its body.

But maybe it can be easier still. Do you really need to use the "operator form" in calling NLPSolve? Could you instead call it with the objective in "expresion form"? The expression would be the result of the add call. Ie,

Optimization:-NLPSolve(
   add(ObjectiveFunction[i], i = 1 .. nn)/nn,
   assume = nonnegative);

acer