segunda derivada numpy de un ndimensional array

Buscamos por distintos sitios para así regalarte la solución para tu inquietud, si tienes alguna duda puedes dejar tu inquietud y te contestamos sin falta, porque estamos para ayudarte.

Solución:

Las segundas derivadas vienen dadas por la matriz Hessiana. Aquí hay una implementación de Python para arreglos ND, que consiste en aplicar el np.gradient dos veces y almacenando la salida apropiadamente,

import numpy as np

def hessian(x):
    """
    Calculate the hessian matrix with finite differences
    Parameters:
       - x : ndarray
    Returns:
       an array of shape (x.dim, x.ndim) + x.shape
       where the array[i, j, ...] corresponds to the second derivative x_ij
    """
    x_grad = np.gradient(x) 
    hessian = np.empty((x.ndim, x.ndim) + x.shape, dtype=x.dtype) 
    for k, grad_k in enumerate(x_grad):
        # iterate over dimensions
        # apply gradient again to every component of the first derivative.
        tmp_grad = np.gradient(grad_k) 
        for l, grad_kl in enumerate(tmp_grad):
            hessian[k, l, :, :] = grad_kl
    return hessian

x = np.random.randn(100, 100, 100)
hessian(x)

Tenga en cuenta que si solo está interesado en la magnitud de las segundas derivadas, puede usar el operador de Laplace implementado por scipy.ndimage.filters.laplaceque es la traza (suma de elementos diagonales) de la matriz hessiana.

Tomando el elemento más pequeño de la matriz Hessian podría usarse para estimar la pendiente más baja en cualquier dirección espacial.

Puede ver la matriz hessiana como un gradiente de gradiente, donde aplica un gradiente por segunda vez para cada componente del primer gradiente calculado aquí hay un enlace de wikipedia que define la matriz hessiana y puede ver claramente que es un gradiente de gradiente, aquí hay un Implementación de python que define gradiente y luego hessian:

import numpy as np
#Gradient Function
def gradient_f(x, f):
  assert (x.shape[0] >= x.shape[1]), "the vector should be a column vector"
  x = x.astype(float)
  N = x.shape[0]
  gradient = []
  for i in range(N):
    eps = abs(x[i]) *  np.finfo(np.float32).eps 
    xx0 = 1. * x[i]
    f0 = f(x)
    x[i] = x[i] + eps
    f1 = f(x)
    gradient.append(np.asscalar(np.array([f1 - f0]))/eps)
    x[i] = xx0
  return np.array(gradient).reshape(x.shape)

#Hessian Matrix
def hessian (x, the_func):
  N = x.shape[0]
  hessian = np.zeros((N,N)) 
  gd_0 = gradient_f( x, the_func)
  eps = np.linalg.norm(gd_0) * np.finfo(np.float32).eps 
  for i in range(N):
    xx0 = 1.*x[i]
    x[i] = xx0 + eps
    gd_1 =  gradient_f(x, the_func)
    hessian[:,i] = ((gd_1 - gd_0)/eps).reshape(x.shape[0])
    x[i] =xx0
  return hessian

Como prueba, la matriz hessiana de (x^2 + y^2) es 2 * I_2 donde I_2 es ​​la matriz identidad de dimensión 2

Las pendientes, las arpilleras y las laplacianas están relacionadas, pero son 3 cosas diferentes.
Comience con 2d: una función (x, y) de 2 variables, por ejemplo, un mapa de altura de una serie de colinas,

• las pendientes, también conocidas como gradientes, son vectores de dirección, una dirección y una longitud en cada punto x y.
  Esto puede ser dado por 2 números dx dy en coordenadas cartesianas, o un ángulo θ y longitud sqrt( dx^2 + dy^2 ) en coordenadas polares. En toda una gama de colinas, obtenemos un campo vectorial.

• Las arpilleras describen la curvatura cerca x ypor ejemplo, un paraboloide o una silla de montar, con 4 números: dxx dxy dyx dyy.

• un laplaciano es 1 número, dxx + dyyen cada punto x y. Sobre una serie de colinas, obtenemos un campo escalar. (Las funciones o colinas con Laplacian = 0 son particularmente suaves).

Las pendientes son ajustes lineales y ajustes cuadráticos hessianos, para pequeños pasos h cerca de un punto xy:

f(xy + h)  ~  f(xy)
        +  slope . h    -- dot product, linear in both slope and h
        +  h' H h / 2   -- quadratic in h

Aquí xy, slope y h son vectores de 2 números, y H es una matriz de 4 numeros dxx dxy dyx dyy.

Nd es similar: las pendientes son vectores de dirección de N números, las hessianas son matrices de N ^ 2 números y las laplacianas 1 número, en cada punto.

(Es posible que encuentre mejores respuestas en math.stackexchange).

Si te ha resultado de provecho nuestro artículo, te agradeceríamos que lo compartas con más juniors así nos ayudas a extender nuestra información.

---

---

Utiliza Nuestro Buscador