Passing an array of variables to a user-defined non-linear function

axsk · June 7, 2017, 9:55am

I am trying to optimize a multivariate function with JuMP, but can’t find a way to pass the arguments.

The current code is:

using JuMP                                                                                                                                                                                                                                                                                                                 
n=100                                                                                                                                                              
m=Model()                                                                                                                                                                                 
@variable(m, 0 <= x[1:n] <= 1)                                                         
f(x)  = rand()   # doenst matter here                                                                                                                                                        
df(x) = rand(n)  # "                                                                                                                                                                                                                                                                                                                                                            
JuMP.register(m, :obj, n, (x...)->f(x), (g,x...)->(g[:] = df(x)))
# and now the line in question:                                                                                                                                                                                                                                                                                                                                                                                                                                                                
@NLobjective(m, Max, obj(x))                                                                                                                                                                                                                                                                                                                                  
solve(m)

No matter how I try denoting the NLobjective, I get the error

ERROR: Incorrect number of arguments for "obj" in nonlinear expression.
 in error(::String) at ./error.jl:21

I also tried obj(x…) but this lead to the same result.

How would I specify this the correct way?

y4lu · June 7, 2017, 10:20am

I tried methods(obj) and got nothing, is it (obj) a part of the JuMP module?
You also have :obj, which kind of reads as a column header(?)

I wouldn’t have thought … is valid code

using JuMP

function f(x...)
  rand(length(x))
  end;

m = model()
param = 100;
@variable(m, 0 <= pvars[1:param] <= 1)
JuMP.register(m, :f, param, f, f)
@NLobjective(m, Max, f(x...))
solve(m)

axsk · June 7, 2017, 10:35am

I define obj as a JuMP-specific user-defined function via the register call (c.f. jump docs)

Concerning the splatting operator ... you might want to look up the julia docs.

Anyone else got some ideas?

y4lu · June 7, 2017, 10:54am

Do you need to define the obj function ?

Edit: You’ve registered the :obj symbol and passed an anonymous definition but there is no function named obj outside the jump model, where you’re calling obj(x)
II: from the jump docs

miles.lubin · June 7, 2017, 12:00pm

This syntax is not supported: Nonlinear Modeling — JuMP -- Julia for Mathematical Optimization 0.17 documentation

All expressions must be simple scalar operations. You cannot use dot, matrix-vector products, vector slices, etc.

If all you’re doing is minimizing an unconstrained function, JuMP does very little for you. I’d recommend using Optim or calling Ipopt directly.

Dan · June 7, 2017, 12:20pm

Perhaps what you are looking for can be achieved with @eval. For example, taking n = 3, the code looks like:

m = Model(solver=IpoptSolver(print_level=0))
n=3
@variable(m, 0 <= x[1:n] <= 1)
f(x...)  = rand()
df(g,x...) = g[:] = rand(n)
JuMP.register(m, :obj, n, f, df)

The problematic @NLobjective could be specialized for n=3 as:

@NLobjective(m, Max, obj(x[1],x[2],x[3]))

and this would work. To make it work for other n defined at runtime, we could build-up this expression and @eval it, as follows:

@eval @NLobjective(m, Max, $(Expr(:call, :obj, [Expr(:ref,:x,i) for i=1:n]...)))

This works, but I’m not really sure, it’s the way to solve the underlying optimization problem.

miles.lubin · June 7, 2017, 12:27pm

That’s also valid, but I would only recommend it to people who understand what’s going on there.

axsk · June 7, 2017, 1:49pm

@Dan: Thank you for the metaway
Beeing a macro though, i hoped that @NLobjective was able to do that transformation itself, do you think this might be worth a ticket?

If all you’re doing is minimizing an unconstrained function, JuMP does very little for you. I’d recommend using Optim or calling Ipopt directly.

I also have linear constraints so Ipopt would be the way to go.
I already implemented the optimization using NLopt but was hoping to find a more optimizer-agnostic formulation using JuMP (although it by now only uses Ipopt for these problems).

I suppose MathProgBase is the other way to go then?

Do I need to define all the methods for AbstractNonlinearModel as in the docs?

How does JuMP handle nonlinear problems using Ipopt without the supply of the second derivatives (in the Ipopt docs these are necessary)?

axsk · June 7, 2017, 2:09pm