Sympy export

[JohannesBuchner]

Dear @MilesCranmer,

I just tried out this package. It works! Fantastic.

I see that the result is a pandas DataFrame. The equation is stored as a string. It seems difficult to parse this back into something usable automatically.

I wonder if it would be easy to add an export to a sympy formula.

Sympy then supports exporting formulas into python functions and also efficient numpy functions. This would allow automatic use of PySR's results. Also, sympy can print formulas with pprint in a easily readable form.

Cheers,
Johannes

[JohannesBuchner]

Here is an example:

from sympy import Symbol, Add, Mul, exp, log

x = Symbol('x')                                                         
y = Symbol('y')                                                         

formula = Mul(Add(x, y), 3.21)                                                    

print(formula)
# --> 3.21*x + 3.21*y

from sympy import lambdify
func = sympy.lambdify((x, y), formula)
print(func(0.21, 0.32))
# --> 1.7013

[JohannesBuchner]

One motivation to ask for this feature is to be able to plot the equations automatically.

[MilesCranmer]

Awesome that it works for you @JohannesBuchner!

Thanks for this post; this would definitely be useful to have. This is on my TODO list, and I think I've reached a point of diminishing returns with backend optimizations so I can look at this now.

I've looked into this in the past, and basically we need to provide a dict of "locals." These are mappings from a string to a sympy function. E.g.,

import sympy
from sympy import sympify
locals = {
    'div': lambda x, y : x/y,
    'mult': lambda x, y : x*y,
    'plus': lambda x, y : x + y,
    'neg': lambda x    : -x,
    'pow': lambda x, y : x**y,
    'cos': lambda x    : sympy.cos(x)
}
sympy_equation = sympify(program_string, locals=locals)

where program_string is the output equation. This dictionary is a map from the operators to the sympy equivalents. Then we would declare a list of symbols for each ['x%d' for i in range(X.shape[1])]. Then, this should transform it to sympy and one can use it for anything downstream.

One question for you: do you think the user provide the sympy functions? Or should those be pre-set somewhere for common strings? I ask because it is possible to provide custom operators... so perhaps the user would want to pass custom sympy code too.

I guess the API could look like this:

pysr(X, y, ...., binary_operators=[...., "special(x, y)=x^2 + y"], extra_sympy_mappings={'special': x**2 + y})

Then that extra_sympy_mappings could be concatenated with a pre-set list of sympy mappings, and used to "sympify" the output.

Thoughts on this?

One other future issue on my TODO list (bottom of the readme) is state saving. I think it would be useful to provide starter equations to the pysr backend that could be used to help discover new equations. Perhaps these could be passed as sympy equations, or simply strings?

Cheers,
Miles

[MilesCranmer]

Alright, added on master! It now outputs three additional columns:

• sympy_format - the sympy equation format.
• lambda_format - the lambdify format, so you can use the equation as a function (args are x0, x1, x2, .... - it follows the same axis order as you passed with X).
• score - the scoring metric I mentioned in loglog linear regression #7 (previously, this was just printed).

[JohannesBuchner]

You are fast. Is it documented somewhere how to use this?

It would seem more user-friendly to me to -- instead of expanding the table to something unwieldy -- provide a function that transforms the result into a sympy formula or lambda function. Unless this makes things much more complicated because internals need to be accessed.

[MilesCranmer]

That's a good idea; I'll weigh these two options a bit more.

Re: documentation, here's an example with custom operators as on the README:

equations = pysr.pysr(X, y, niterations=100,
    binary_operators=["mult", "plus", "special(x, y) = x^2 + y"],
    extra_sympy_mappings={'special': lambda x, y: x**2 + y},
    unary_operators=["cos"])

So, you can access the sympy equations with, e.g., equations.loc[2, 'sympy_format'] - to get the sympy equation for row 2. Then that can be used with sympy functionality, e.g., latex: https://docs.sympy.org/latest/tutorial/printing.html.

To get something to evaluate (maybe I can provide something to generate plots later?), use eg y = equations.loc[2, 'lambda_format'](x0, x1, ...) for whatever input values of x0, x1 you want.

[MilesCranmer]

I think your plot idea is a really nice one. It would be great to be able to use PySR in a Jupyter notebook and get to plot out each equation on the data, and have them shown in LaTeX too. Perhaps the Pandas table is a good option, since it would contain everything necessary for downstream options? Since one can then pass all the equations to a function, or a single equation at a time.