Parsing a string into a differentiable expression for a GenericDeterministicModel

[jduerholt]

Hi,

I have a kind of esoteric question ;)

Do you know if it is possible to somehow parse a string, encoding a mathematical expression, into a differentiable torch expression somehow like pd.eval?

Botorch related use case would be for example the case of a frontend in which a user can type a mathematical expression which is then used as callable in a GenericDeterministicModel.

Any thoughts on this?

Best,

Johannes

[Balandat]

Hmm so if the string was just some pytorch code à la str = "torch.sum(x**2) / torch.min(x)" then that could be done easily via def obj(x): return eval(s, {}, {"x": x}). This usually not a great thing to do though...

If you wanted this to be fancier and just use math expressions instead of the exact torch function you'd have to have some way or mapping those strings to the torch function. It seems challenging to do this for all of them, but if you are just interested in basic ones in the torch. namespace maybe you can get away with parsing the string and putting a torch. prefix in front of everything....

And then of course you could get arbitrarily complicated with the parsing if you wanted to. In a real world application with a GUI you'd probably want to have a corpus of possible methods and then use typeahead for selecting them in the interface....

[jduerholt]

I just came across this package https://github.com/patrick-kidger/sympytorch which takes sympy expressions and translates them to differentiable torch modules. Looks very helpful for defining complex nonlinear constraints and deterministic models via a frontend ;)

[Balandat]

Interesting, thanks for flagging! Do you have a sense of how easy it is to serialized sympy objects (and how compact those would be)? One of the challenges that we have on the Ax side is to store things like nonlinear objectives on the experiment when writing it to json/db, so if that's not hard to do that could be helpful.

[Balandat]

I guess sympy's parsing module should help with that (in that we may just be able to save the string and re-parse when needed): https://docs.sympy.org/latest/modules/parsing.html

[jduerholt]

I am not a sympy expert, but I played bit with it as we have the same issues with serializing to json using our backend. You are able to do the following for simplicity:

import sympy, torch, sympytorch

sympy_module = sympytorch.SymPyModule(expressions=[sympy.S("2*x**2+y")])
x_ = torch.rand((1024, 8 , 2))
sympy_module(**{"x": x_[...,0], "y": x_[...,1]})

Via sympy.S, you can just intilialize from a simple string, of course there are much more options in the parsing module.

[Balandat]

I looked at this a bit and it would be a nice interface indeed. Unfortunately, all of these string parsing functions use eval() under the hood, so this is a rather big security risk if inputs aren't properly sanitized (e.g. when used with a web interface). But it could be useful in some environments where the user can already execute arbitrary code anyway...

[jduerholt]

I did not know this. This is really a pity. I have to think about the implications and possible workarounds. Thanks for flagging!