Constraints wrongly evaluated/applied???

[fpmw]

Hello,

I have the following constraint to an unitairy function 'myconst': { "myconst": 4}
The variables have complexity 3, constants complexity 4 and basic operators have complexity 1.

As a result the expression 'X0 * 0.041657' has complexity 8.

Why do I see the following in the end result 'myconst(X0 * 0.041657)'. Shouldn't this be prevented by the constraints?

Your help is appriciated!

Regards,
Frank

[MilesCranmer]

Can you paste your full code here?

[fpmw]

The full code is a bit long. But here are the parameters I pass to the Regressor.
The p1 and p2 are just multipliers to break the recursive '*' operator loop and restrict one sigmoid. p2 is not even used.

Note that in Nested_Constraints the myconst operator allows the '*', which is wrong, but this gave me the strange resut of myconst given before.

    Constraints = {
            "sigmoid":      (8, 8),
            "exp":          9,
            "^":            (8, 1),
            "myfac":        (-1),
            "myconst":      4,
            "p1":           (-1, -1),
            "p2":           (1, 1),
            "*":            (-1, -1),
            "/":            (-1, -1),
            "neg":          (-1),

    Nested_Constraints = {
            "sigmoid":      {"/":1, "*":1, "p1":1, "p2":0, "+":2, "-":2,    "neg":1,        "exp":0,        "^":0,  "myfac":1,      "sigmoid":0,    "myconst":1},
            "exp":          {"/":1, "*":1, "p1":1, "p2":0, "+":1, "-":1,    "neg":1,        "exp":0,        "^":0,  "myfac":1,      "sigmoid":0,    "myconst":1},
            "^":            {"/":1, "*":1, "p1":1, "p2":0, "+":1, "-":1,    "neg":1,        "exp":0,        "^":0,  "myfac":1,      "sigmoid":0,    "myconst":1},
            "myfac":        {"/":1, "*":1, "p1":1, "p2":0, "+":1, "-":1,    "neg":1,        "exp":1,        "^":1,  "myfac":0,      "sigmoid":0,    "myconst":1},
            "myconst":      {"/":0, "*":1, "p1":0, "p2":0, "+":0, "-":0,    "neg":0,        "exp":0,        "^":0,  "myfac":0,      "sigmoid":0,    "myconst":0},
            "neg":          {"/":1, "*":1, "p1":1, "p2":0, "+":1, "-":1,    "neg":0,        "exp":1,        "^":1,  "myfac":1,      "sigmoid":1,    "myconst":1},
            "/":            {"/":0, "*":1, "p1":1, "p2":0, "+":1, "-":1,    "neg":1,        "exp":1,        "^":1,  "myfac":1,      "sigmoid":0,    "myconst":1},
            "*":            {"/":0, "*":0, "p1":1, "p2":0, "+":0, "-":0,    "neg":0,        "exp":0,        "^":0,  "myfac":0,      "sigmoid":1,    "myconst":0},
            "p1":           {"/":1, "*":0, "p1":1, "p2":0, "+":1, "-":1,    "neg":1,        "exp":1,        "^":1,  "myfac":1,      "sigmoid":0,    "myconst":1},
            "p2":           {"/":0, "*":0, "p1":0, "p2":0, "+":0, "-":0,    "neg":0,        "exp":0,        "^":0,  "myfac":0,      "sigmoid":0,    "myconst":0},
            "+":            {"/":1, "*":1, "p1":1, "p2":0, "+":1, "-":1,    "neg":0,        "exp":0,        "^":0,  "myfac":0,      "sigmoid":0,    "myconst":1},
            "-":            {"/":1, "*":1, "p1":1, "p2":0, "+":1, "-":1,    "neg":0,        "exp":0,        "^":0,  "myfac":0,      "sigmoid":0,    "myconst":1},
    }


    ComplexityOfOperators = {
            "sigmoid":      7,
            "exp":          4,
            "^":            4,
            "neg":          1,
            "myfac":        2,
            "myconst":      1,
            "+":            1,
            "-":            1,
            "p1":           1,
            "p2":           1,
            "*":            1,
            "/":            1,
    }

    UnaryOperators = [
            "exp",
            "neg",
            "myfac(x::T) where {T} = x < 0 || x > 1000 ? T(NaN) : T(factorial(big(convert(Int, round(x)))))",
            "myconst(x::T) where {T} = T(round(x))"
    ]

    BinaryOperators = [
            "+",
            "-",
            "p1(x, y) = (x*y)",
            "p2(x, y) = (x*y)",
            "*",
            "/",
            "^",
            "sigmoid(x, y) =  1/(y+exp(-x))",

]

with:
Complexity_Of_Constants = 4
Complexity_Of_Variables = 3

[MilesCranmer]

Thanks. So indeed the constraint appears to be violated... Can you please paste the full entire code + dataset so I can reproduce it?

Also, what is the entire pareto front? Is it just that one expression that is violating constraints, or is it multiple expressions?

[fpmw]

Hello Miles,

Can I send the code? I think it is cumbersome to put it here as a comment.
Is there a easy way to get the pareto front?

Regards,
Frank

[MilesCranmer]

model.equations_ is a Pandas dataframe of the pareto front

Maybe you could make a GitHub "gist" with the code and link it here? The important part is that I can run it.

[fpmw]

Hello miles,

I try to reconstruct de error. No such luck... I will keep working on it.