Custom functions as nonterminals

[shubham-root]

I want to try this out with custom functions as non-terminal kernels, unsure if that is supported, but could you point if I wanted implement something of the sort where should I look into?

[folivetti]

For now we don't support custom functions but we're planning this feature soon.

Could you detail what functions you wanted included and what kind of interface you'd like for custom functions?

[shubham-root]

@folivetti apologies I moved away from my GP experiments at that moment, and thanks a lot for taking note. We had been playing around with DEAP and quite liked the interface it offers for adding custom functions. It utilizes an addPrimitive method to pass declared python functions.
Something of that sort would be pretty neat I recon.

[folivetti]

@shubham-root could you provide one example of custom function that you need? Just so I can think about the best way to implement here :-)

[shubham-root]

@folivetti sure e.g.

def create_main_primitive_set(self) -> gp.PrimitiveSetTyped:
        """Create main primitive set with shape drawing functions."""
        pset = gp.PrimitiveSetTyped("MAIN", [float, float], float)
        
        # Shape primitives
        def circle(center_x, center_y, radius, x, y):
            dx = x - center_x
            dy = y - center_y
            return 1.0 if dx*dx + dy*dy <= radius*radius else 0.0
        
        pset.addPrimitive(circle, [float, float, float, float, float], float)
        
        def ellipse(center_x, center_y, radius_x, radius_y, rotation, x, y):
            dx = x - center_x
            dy = y - center_y
            # Rotate point
            cos_r = math.cos(rotation)
            sin_r = math.sin(rotation)
            rx = dx * cos_r + dy * sin_r
            ry = -dx * sin_r + dy * cos_r
            val = (rx / radius_x)**2 + (ry / radius_y)**2
            return 1.0 if val <= 1.0 else 0.0
        
        pset.addPrimitive(ellipse, [float, float, float, float, float, float, float], float)
        
        def quadrilateral(v1x, v1y, v2x, v2y, v3x, v3y, v4x, v4y, x, y):
            # Simple point-in-quad check (approximate using bounding box for GP simplicity)
            min_x = min(v1x, v2x, v3x, v4x)
            max_x = max(v1x, v2x, v3x, v4x)
            min_y = min(v1y, v2y, v3y, v4y)
            max_y = max(v1y, v2y, v3y, v4y)
            if x >= min_x and x <= max_x and y >= min_y and y <= max_y:
                return 1.0
            return 0.0
        
        pset.addPrimitive(quadrilateral, [float, float, float, float, float, float, float, float, float, float], float)
        
        # Combining operators for shapes (union, intersection, etc.)
        def shape_union(a, b):
            return max(a, b)
        
        def shape_intersection(a, b):
            return min(a, b)
        
        def shape_difference(a, b):
            return max(a, 1.0 - b)
        
        pset.addPrimitive(shape_union, [float, float], float)
        pset.addPrimitive(shape_intersection, [float, float], float)
        pset.addPrimitive(shape_difference, [float, float], float)
        
        # Basic arithmetic for parameters
        pset.addPrimitive(operator.add, [float, float], float)
        pset.addPrimitive(operator.sub, [float, float], float)
        pset.addPrimitive(operator.mul, [float, float], float)
        
        # Constants
        pset.addEphemeralConstant("const", lambda: random.uniform(-1, 1), float)
        pset.addEphemeralConstant("radius", lambda: random.uniform(0, 1), float)
        pset.addEphemeralConstant("angle", lambda: random.uniform(0, math.pi*2), float)
        
        # Input arguments
        pset.renameArguments(ARG0='x', ARG1='y')
        
        return pset

in this DEAP experiment example excerpt I have created geometric shape as 'non-terminals' with custom parameterization i.e. in the case above for circle both its center and its radius, in an experiment where symbolic functions in x, y are used to infer to LOGO like image input.

For simpler example I should be able to write a function like:

def special_add(x, y):
    return x+y+1

# and add it as non-terminal
pset.addPrimitive(special_add, [float, float], float)

What I mean is any function ideally after defining its arity and types (input and output) if allowed to be added as non-terminal would give a lot of flexibility in making this a very powerful GP tool.

[folivetti]

Thanks!! This seems interesting. I'll have to think a bit the best way to do it, as the backend of the algorithm is implemented in another language, so I have to see how to interoperate with a Python custom function. I'll let you know when I figure it out

[shubham-root]

Yeah I noticed haskell underneath, would have tried opening a PR myself otherwise with an attempt on the same.