[BUG]: Expresion template has not attribute sympy

[PhyAMR]

What happened?

I have dfined a template expresion and I can't get the sympy expresion of the model. It worked perfectly fine without that, but I wanted to yield expresions of 2 variables but I need a sympy expresion te evaluate the result and plot the function.

Here is my function and an example:

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from pysr import PySRRegressor, TemplateExpressionSpec

def symbolic_regression(df, input_cols, target_col, threshold=0.2):
    X = df[input_cols].values
    y = df[target_col].values

    # Split the data
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.3, random_state=12
    )

    if len(input_cols) == 2:
        spec = TemplateExpressionSpec(
            expressions=["f"],
            variable_names=["x0", "x1"],
            combine="f(x0, x1)"
        )
    else:
        spec = TemplateExpressionSpec(
            expressions=["f"],
            variable_names=["x0"],
            combine="f(x0)"
        )

    model = PySRRegressor(
        binary_operators=["+", "-", "*", "/", "^"],
        unary_operators=["exp", "log", "sqrt"],
        model_selection="best",
        verbosity=0,
        constraints={'^': (-2, 2)},
        expression_spec=spec
    )

    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)

    return model.sympy()

# --------------------------
# Example
# --------------------------


np.random.seed(0)
x = np.random.uniform(-2, 2, 100)
y = np.random.uniform(-2, 2, 100)
z = 3 * x + 2 * y + np.sin(x)  

df = pd.DataFrame({
    "x": x,
    "y": y,
    "z": z
})


expr = symbolic_regression(df, input_cols=["x", "y"], target_col="z")
print(expr)

     

Code example

Version

1.5.6

Operating System

Windows

Package Manager

Other (specify below)

Interface

Script (i.e., python my_script.py)

Relevant log output

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[1], line 59
     52 df = pd.DataFrame({
     53     "x": x,
     54     "y": y,
     55     "z": z
     56 })
     58
---> 59 expr = symbolic_regression(df, input_cols=["x", "y"], target_col="z")
     60 print(expr)

Cell In[1], line 40, in symbolic_regression(df, input_cols, target_col, threshold)
     37 model.fit(X_train, y_train)
     38 y_pred = model.predict(X_test)
---> 40 return model.sympy()

File c:\Users\alvar\Desktop\UCM\Cuarto Curso\TFG\.venv\Lib\site-packages\pysr\sr.py:2437, in PySRRegressor.sympy(self, index)
   2419 """
   2420 Return sympy representation of the equation(s) chosen by `model_selection`.
   2421 
   (...)
   2434     SymPy representation of the best equation.
   2435 """
   2436 if not self.expression_spec_.supports_sympy:
-> 2437     raise ValueError(
   2438         f"`expression_spec={self.expression_spec_}` does not support sympy export."
   2439     )
   2440 self.refresh()
   2441 best_equation = self.get_best(index=index)

ValueError: `expression_spec=<pysr.expression_specs.TemplateExpressionSpec object at 0x000001CC97F84090>` does not support sympy export.

Extra Info

I'm using poetry created a virtual enviroment so I'm running my script like using a regular enviroment, I'm not doing poetry run something.py

[PhyAMR]

I found a solution to the problem

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from pysr import PySRRegressor, TemplateExpressionSpec
from sympy import symbols
from sympy.parsing.sympy_parser import parse_expr, standard_transformations, implicit_multiplication_application

def symbolic_regression(df, input_cols, target_col, threshold=0.2):
    X = df[input_cols].values
    y = df[target_col].values

    # Split the data
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.3, random_state=12
    )

    if len(input_cols) == 2:
        spec = TemplateExpressionSpec(
            expressions=["f"],
            variable_names=["x0", "x1"],
            combine="f(x0, x1)"
        )
    else:
        spec = TemplateExpressionSpec(
            expressions=["f"],
            variable_names=["x0"],
            combine="f(x0)"
        )

    model = PySRRegressor(
        binary_operators=["+", "-", "*", "/", "^"],
        unary_operators=["exp", "log", "sqrt"],
        model_selection="best",
        verbosity=0,
        constraints={'^': (-2, 2)},
        expression_spec=spec
    )

    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)

    return model.get_best()['equation']

# --------------------------
# Ejemplo para probarla
# --------------------------

# Crear un DataFrame con una función conocida de dos variables
np.random.seed(0)
x = np.random.uniform(-2, 2, 100)
y = np.random.uniform(-2, 2, 100)
z = 3 * x + 2 * y + np.sin(x)  # relación no lineal simple

df = pd.DataFrame({
    "x": x,
    "y": y,
    "z": z
})

# Ejecutar la función
expr = symbolic_regression(df, input_cols=["x", "y"], target_col="z")
print(expr)



# Define the symbols
x0, x1 = symbols("x0 x1")

# Define the local dictionary for variable mapping
local_dict = {"x0": x0, "x1": x1}
rhs = expr.split('=', 1)[1].strip()
rhs = rhs.replace("^", "**")
f = rhs.replace("#1", "x0").replace("#2", "x1")

# Define the transformations to handle implicit multiplication
transformations = standard_transformations + (implicit_multiplication_application,)

# Parse the expression
expr2 = parse_expr(f, local_dict=local_dict, transformations=transformations)
print(expr2)
from sympy import lambdify

# Create a numerical function
f_numeric = lambdify((x0, x1), expr2, modules="numpy")

# Evaluate the function
result = f_numeric(1.0, 2.0)

print(result)

[PhyAMR]

Also but maybe for another BUG (let me know if that is the case) I want to ensure that the expresion matches the number of input cols (even if I get a worst fit) to do so (and after I couldn't find anything in the docs) chatgpt gave me this line for the template:

spec = TemplateExpressionSpec(
    expressions=["f", "g"],
    variable_names=["x0", "x1"],
    combine="((; f, g), (x0, x1)) -> f(x0) + g(x1)"
)

But it gives me this error with julia:

ArgumentError: Failed to infer number of features used by (:f, :g)
Stacktrace:
  [1] infer_variable_constraints(::Val{(:f, :g)}, num_parameters::NamedTuple, combiner::Any)
    @ SymbolicRegression.TemplateExpressionModule C:\Users\alvar\.julia\packages\SymbolicRegression\BBPwF\src\TemplateExpression.jl:238
  [2] macro expansion
    @ .\some.jl:158 [inlined]
  [3] #_#2
    @ C:\Users\alvar\.julia\packages\SymbolicRegression\BBPwF\src\TemplateExpression.jl:141 [inlined]
  [4] TemplateStructure
    @ C:\Users\alvar\.julia\packages\SymbolicRegression\BBPwF\src\TemplateExpression.jl:122 [inlined]
  [5] #_#1
    @ C:\Users\alvar\.julia\packages\SymbolicRegression\BBPwF\src\TemplateExpression.jl:118 [inlined]
  [6] TemplateStructure
    @ C:\Users\alvar\.julia\packages\SymbolicRegression\BBPwF\src\TemplateExpression.jl:112 [inlined]
  [7] (TemplateStructure{(:f, :g), Kp, E, NF} where {Kp, E<:Function, NF<:(NamedTuple{(:f, :g)})})(combine::var"#367#369")
    @ SymbolicRegression.TemplateExpressionModule C:\Users\alvar\.julia\packages\SymbolicRegression\BBPwF\src\TemplateExpression.jl:112
  [8] top-level scope
    @ C:\Users\alvar\.julia\packages\SymbolicRegression\BBPwF\src\TemplateExpressionMacro.jl:91
  [9] eval
    @ .\boot.jl:430 [inlined]
 [10] eval
    @ .\Base.jl:130 [inlined]
 [11] pyjlmodule_seval(self::Module, expr::Py)
    @ PythonCall.JlWrap C:\Users\alvar\.julia\packages\PythonCall\WMWY0\src\JlWrap\module.jl:13
 [12] _pyjl_callmethod(f::Any, self_::Ptr{PythonCall.C.PyObject}, args_::Ptr{PythonCall.C.PyObject}, nargs::Int64)
    @ PythonCall.JlWrap C:\Users\alvar\.julia\packages\PythonCall\WMWY0\src\JlWrap\base.jl:67
 [13] _pyjl_callmethod(o::Ptr{PythonCall.C.PyObject}, args::Ptr{PythonCall.C.PyObject})
    @ PythonCall.JlWrap.Cjl C:\Users\alvar\.julia\packages\PythonCall\WMWY0\src\JlWrap\C.jl:63