scipy.misc.derivative für multiple Argument-Funktion

Question

Es ist einfach, die partiellen Ableitungen einer Funktion an einem Punkt in Bezug auf das erste Argument mit der SciPy-Funktion scipy.misc.derivative zu berechnen. Hier ein Beispiel:

def foo(x, y): 
    return(x**2 + y**3) 

from scipy.misc import derivative 
derivative(foo, 1, dx = 1e-6, args = (3,)) 

Aber wie würde ich mich über die Ableitung der Funktion foo in Bezug auf das zweite Argument zu nehmen? Eine Möglichkeit, an die ich denken kann, ist, eine Lambda-Funktion zu erzeugen, die die Argumente umschreibt, aber das kann schnell umständlich werden.

Gibt es auch eine Möglichkeit, ein Array von partiellen Ableitungen in Bezug auf einige oder alle Argumente einer Funktion zu generieren?

Answer 1

würde ich ein einfaches Wrapper, etwas entlang der Linien von

def partial_derivative(func, var=0, point=[]): 
    args = point[:] 
    def wraps(x): 
     args[var] = x 
     return func(*args) 
    return derivative(wraps, point[var], dx = 1e-6) 

Demo schreiben:

>>> partial_derivative(foo, 0, [3,1]) 
6.0000000008386678 
>>> partial_derivative(foo, 1, [3,1]) 
2.9999999995311555 

Answer 2

Ja, wird es in sympy umgesetzt. Demo:

>>> from sympy import symbols, diff 
>>> x, y = symbols('x y', real=True) 
>>> diff(x**2 + y**3, y) 
3*y**2 
>>> diff(x**2 + y**3, y).subs({x:3, y:1}) 
3 

Answer 3

Hier ist eine Antwort für die numerische Differenzierung mit numdifftools.

import numpy as np 
import numdifftools as nd 

def partial_function(f___,input,pos,value): 
    tmp = input[pos] 
    input[pos] = value 
    ret = f___(*input) 
    input[pos] = tmp 
    return ret 

def partial_derivative(f,input): 
    ret = np.empty(len(input)) 
    for i in range(len(input)): 
     fg = lambda x:partial_function(f,input,i,x) 
     ret[i] = nd.Derivative(fg)(input[i]) 
    return ret 

Dann:

print (partial_derivative(lambda x,y: x*x*x+y*y,np.array([1.0,1.0]))) 

Gibt:

[ 3. 2.]