Multiple arguments in python

Question

I'm using the built-in Levenberg-Marquardt algorithm to fit some data. It calls some function which needs to have the syntax foo(x,a1,a2,...,an), where an are parameters and the number of input arguments specifies the number of dimensions the L-M algorithm minimizes. Currently this foo function calls some other function I have defined as :

foo(x, a1, a2, ..., an):
    ai = [a1,a2,...,an]
    result = somefun(x,ai)
    return result

Is there a way to use a compact syntax in this case? I would like to be able to define some parameter L = n, which specifies the number of input arguments somewhere before the function definition.

Note: Please also read that using foo(x,*ai), will generate ValueError: Unable to determine number of fit parameters before marking as duplicate.

I am not clear, then, on what exactly you are trying to accomplish. What, roughly, would you like the end result to look like? — TheBlackCat, Mar 11 '15 at 16:26

score 2 · Answer 1 · answered Mar 10 '15 at 16:56

2

Use the *args syntax:

foo(x, *args):
    result = somefun(x, args)
    return result

This grabs all arguments besides x and stores them in the tuple args.

answered Mar 10 '15 at 16:56

TheBlackCat

9,791
3
24
31

This messes up the L-M function which has no idea of the number of gradients it needs to calculate. L-M is called with foo as an arguments and gets the number of dimensions from the number of arguments allowed -1 – MGrd Mar 10 '15 at 17:02
What do you mean that it "gets the number of dimensions from the number of arguments allowed -1". How does it do that? – Andrew Jaffe Mar 11 '15 at 10:53
The built-in LM method (scipy.optimize.curve_fit) takes as input argument foo. The first input argument is x and the rest are parameters which the L-M algorithm optimizes (this is a least square method). I would like to define some parameter before defining this function, say N= 5, which would then define this function as foo(r,a1,a2,a3,a4,a5). Right now, when I want to change the number of parameters, I have to modify foo by hand, which makes it tiresome when N becomes large (say N~30-60). – MGrd Mar 11 '15 at 20:31

score 1 · Answer 2 · answered Apr 21 '15 at 19:25

You should probably specify in your question that the function you're using is from scipy, which is not part of the standard library.

From the docstring for scipy.optimize.curve_fit:

optimize.curve_fit(f, xdata, ydata, p0=None, sigma=None, absolute_sigma=False, check_finite=True, **kw)
...
Parameters
----------

f : callable
The model function, f(x, ...).  It must take the independent
variable as the first argument and the parameters to fit as
separate remaining arguments.

xdata : An M-length sequence or an (k,M)-shaped array
for functions with k predictors.
The independent variable where the data is measured.

ydata : M-length sequence
The dependent data --- nominally f(xdata, ...)

p0 : None, scalar, or N-length sequence
Initial guess for the parameters.  If None, then the initial
values will all be 1 (**if the number of parameters for the function
can be determined using introspection, otherwise a ValueError
is raised**).
...

With the foo(x,*args) construction, the number of parameters can't be determined from introspection, so you get your ValueError, but you can still pass a sequence of initial values via the p0 argument, which will let the algorithm know that the number of parameters is the length of that sequence. So for example,

n=5
foo(x,*args):
    return somefun(x,args)
curve_fit(foo,x0,y0,p0=[1]*n)

user2357112 · Answer 3 · 2015-04-21T19:40:14.467

The function you're using, scipy.optimize.curve_fit, only needs to introspect f to find the number of arguments if you don't pass an initial guess as a p0 argument. If you can provide a good guess, do so; otherwise, you can pass in a guess of all ones:

scipy.optimize.curve_fit(f, xdata, ydata, p0=[1]*n)

Then you can use def f(x, *args) syntax.

If for some reason you really need f to have independently specified positional arguments, I would use exec. That's rarely a good idea, but in this case, it may be warranted.

template = '''
def f(x, {args}):
    return somefun(x, [{args}])
'''

definition = template.format(args=', '.join('a'+str(i) for i in xrange(n)))
namespace = {'somefun': somefun}
exec definition in namespace
f = namespace['f']

Multiple arguments in python

3 Answers3