Writing an indicator function in JuMP

jump

#1

I’d like to penalize negative values for a linear function of parameters without using an @constraint (since I’d like it to be possible, but costly to violate the constraint)

Is there a way to do this within JuMP w/o defining a custom function?

My model is something like the following:

@variables m begin
        coeff_0
        coeffs_X[j = 1:P]
    end

@NLexpression(
            m,
            B[i = 1:N],
            coeff_0 + sum( X[i, j] * coeffs_X[j] for j = 1:P)
)

@NLobjective(
            m,
            Min,
            sum( (y[i] - B[i]) for i = 1:N )^2
)

And I’d like to penalize B[i] being negative.


#2

A proposed solution, given help from @mbesancon:

@variables m begin
       coeff_0
       coeffs_X[j = 1:P]
       negative_indicator[i = 1:N], Bin
   end

@NLexpression(
           m,
           B[i = 1:N],
           coeff_0 + sum( X[i, j] * coeffs_X[j] for j = 1:P)
)

@NLconstraint(
           m,
           i in 1:N,
           -M * negative_indicator[i] <= B[i]
)

@NLobjective(
           m,
           Min,
           sum( (y[i] - B[i]) for i = 1:N )^2 + sum(c * negative_indicator[i] for i = 1:N)
)

where M is chosen to be large enough that it bounds the lowest value of B and c is a penalty coefficient


#3

An alternative solution that penalizes the extent of the negativity of each B[i].

@variables m begin
       coeff_0
       coeffs_X[j = 1:P]
       negative_penalizer[i = 1:N] >= 0
   end

@NLexpression(
           m,
           B[i = 1:N],
           coeff_0 + sum( X[i, j] * coeffs_X[j] for j = 1:P)
)

@NLconstraint(
           m,
           i in 1:N,
           negative_penalizer[i] + B[i] >= 0
)

@NLobjective(
           m,
           Min,
           sum( (y[i] - B[i]) for i = 1:N )^2 + sum(c * negative_penalizer[i] for i = 1:N)
)

where c > 0 is a penalty coefficient


#4

I think all constraints and the objective are linear expressions, you can replace the constraint with @constraint ... and the objective with @objective


#5

The objective has squares, but yeah :slight_smile:


#6

Oops sorry I had missed this one! In case of quadratic expressions, JuMP supports them directly, see http://www.juliaopt.org/JuMP.jl/0.18/refexpr.html#constraint-references.


#7

Is there a particular benefit to defining quadratic expressions like this vs writing them out the way I did? Just an efficiency thing?


#8

Not sure there,but I think you can get more information from the solving process and solution (dual values of constraints for instance).
JuMP will also pretty-print the constraints, which it will not do with non-linear expression I believe