function minimization in r with constraints on function of parameters

Many libraries are available in R to perform minimisation. However, all the ones I could find (e.g. rcgmin, or optimx) only allow lower and upper bounds on the input parameters:

opt_Params <- Rcgmin(par = Params_init,
                     fn = cost_func,
                     gr = params_grad,
                     lower = min_par,
                     upper = max_par
                     )

I'm looking for something different: boundaries not on the input parameters, but on the values of a function that takes them.

Concretely, my cost_func is a cost function that measures the sum of the squared residuals between my (fixed) observed data Y_obs and the prediction from my fitted parameters Y_calc:

cost_func <- function(Params) {
        X <- Params[1:(num_items*num_features)]
        dim(X) <- c(num_items,num_features)

        Theta <- Params[(num_items*num_features+1):length(Params)]
        dim(Theta) <- c(num_users,num_features)

        Y_calc <- X * t(Theta)
        J <- ((Y_calc - Y_obs) * (Y_calc - Y_obs))

        cost <- sum(rowSums(J)[])

        return(cost)
}

Minimising the cost function, I can ensure that my predicted Y_calc get ever closer to Y_obs.

This however allows for arbitrary values in Y_calc. What I would like to do is to impose the same boundaries as I know to be present in Y_obs (between 0 and 10 - this is a collaborative filtering algorithm). So I'm not trying to put constraints on my input parameters, but on a function of them (namely, on every element of Y_calc <- X * t(Theta)).

Is there an R minimisation library in which this is possible? Or do I need to change my approach?

Solution

I think you can try something like this :

library(DEoptim)

cost_func <- function(Params) 
{
  X <- Params[1 : (num_items * num_features)]
  dim(X) <- c(num_items,num_features)
  Theta <- Params[(num_items * num_features + 1) : length(Params)]
  dim(Theta) <- c(num_users,num_features)
  Y_calc <- X * t(Theta)
  
  if((Y_calc < 0) | (Y_calc > 10))
  {
    return(10 ^ 30)
    
  }else
  {
    J <- ((Y_calc - Y_obs) * (Y_calc - Y_obs))
    cost <- sum(rowSums(J)[])
    return(cost)
  }
}

DEoptim(par = Params_init,
        fn = cost_func,
        lower = min_par,
        upper = max_par)

If a parameter set generates a value of Y_calc that is between 0 and 10, the objective function will return a very high value. Hence, the DEoptim algorithm will not consider this set of parameters as a candidate solution.