Si te encuentras con algún detalle que te causa duda puedes dejarlo en los comentarios y haremos todo lo posible de ayudarte lo más rápido posible.
Solución:
Puedes usar Harvard autograd biblioteca (enlace), donde grad y jacobian tomar una función como su argumento:
import autograd.numpy as np
from autograd import grad, jacobian
x = np.array([5,3], dtype=float)
def cost(x):
return x[0]**2 / x[1] - np.log(x[1])
gradient_cost = grad(cost)
jacobian_cost = jacobian(cost)
gradient_cost(x)
jacobian_cost(np.array([x,x,x]))
De lo contrario, podría utilizar el jacobian método disponible para matrices en sympy:
from sympy import sin, cos, Matrix
from sympy.abc import rho, phi
X = Matrix([rho*cos(phi), rho*sin(phi), rho**2])
Y = Matrix([rho, phi])
X.jacobian(Y)
Además, también te puede interesar ver esta variante de bajo nivel (enlace). MATLAB proporciona buena documentación sobre su jacobian función aquí.
El jacobiano solo se define para valores vectoriales funciones. No puede trabajar con arreglos llenos de constantes para calcular el jacobiano; debe conocer la función subyacente y sus derivadas parciales, o la aproximación numérica de estas. Esto es obvio cuando consideras que la derivada (parcial) de una constante (con respecto a algo) es 0.
En Python, puede trabajar con módulos matemáticos simbólicos como SymPy o SymEngine calcular jacobianos de funciones. Aquí hay una demostración simple de un ejemplo de Wikipedia:
Utilizando el SymEngine módulo:
Python 2.7.11 (v2.7.11:6d1b6a68f775, Dec 5 2015, 20:40:30) [MSC v.1500 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
>>> import symengine
>>>
>>>
>>> vars = symengine.symbols('x y') # Define x and y variables
>>> f = symengine.sympify(['y*x**2', '5*x + sin(y)']) # Define function
>>> J = symengine.zeros(len(f),len(vars)) # Initialise Jacobian matrix
>>>
>>> # Fill Jacobian matrix with entries
... for i, fi in enumerate(f):
... for j, s in enumerate(vars):
... J[i,j] = symengine.diff(fi, s)
...
>>> print J
[2*x*y, x**2]
[5, cos(y)]
>>>
>>> print symengine.Matrix.det(J)
2*x*y*cos(y) - 5*x**2
En python 3, puede probar el paquete sympy:
import sympy as sym
def Jacobian(v_str, f_list):
vars = sym.symbols(v_str)
f = sym.sympify(f_list)
J = sym.zeros(len(f),len(vars))
for i, fi in enumerate(f):
for j, s in enumerate(vars):
J[i,j] = sym.diff(fi, s)
return J
Jacobian('u1 u2', ['2*u1 + 3*u2','2*u1 - 3*u2'])
que da:
Matrix([[2, 3],[2, -3]])
Si haces scroll puedes encontrar las explicaciones de otros sys admins, tú asimismo eres capaz insertar el tuyo si dominas el tema.