Ceres introducción y ejemplos (8) Sobre Derivados (Derivados Analíticos)

Considere el problema de ajuste de la siguiente curva ( Rat43 ):
$\frac{b_1}{(1+e^{b_2-b_3x})^ { 1/b_4}}$
Es decir, dados unos datos $\{x_i, y_i\},\ \forall i=1,... ,n$ mejor se ajusten a los datos $b, b, b, b$ 。

El problema al que nos enfrentamos es resolver $b_1, b_2, b_3, b_4$ 1
$mi (segundo, b, b, b) = i F^{2} (segundo, b, b, b; X, y) = i (\frac{b}{( 1 + mi ^{b - segundo X} ) ^{1/ segundo}} - y)$

La noción de mejor ajuste depende de la elección de una función objetivo para medir la calidad del ajuste, que a su vez depende de los procesos ruidosos subyacentes que produjeron las observaciones. Minimizar la suma de las diferencias al cuadrado es lo correcto cuando el ruido es gaussiano. En este caso, el valor óptimo para el parámetro es la estimación de máxima verosimilitud.

Para resolver este problema usando el solucionador de Ceres, necesitamos definir una función de costo para calcular el residuo f y sus derivados con respecto a b1, b2, b3 y b4 dados x e y. Según los conocimientos de cálculo en matemáticas avanzadas, podemos calcular una serie de derivadas de f:
$\begin{split} D_1 f(b_1, b_2, b_3, b_4; x,y ) &= \frac{1}{(1+e^{b_2-b_3x})^{1/b_4}}\\ D_2 f(b_1, b_2, b_3, b_4; x,y) &= \frac{- b_1e^{b_2-b_3x}}{b_4(1+e^{b_2-b_3x})^{1/b_4 + 1}} \\ D_3 f(b_1, b_2, b_3, b_4; x,y) &= \ frac{b_1xe^{b_2-b_3x}}{b_4(1+e^{b_2-b_3x})^{1/b_4 + 1}} \\ D_4 f(b_1, b_2, b_3, b_4; x,y) & = \frac{b_1 \log\left(1+e^{b_2-b_3x}\right) }{b_4^2(1+e^{b_2-b_3x})^{1/b_4}} \end{dividir}$

A partir de estas derivadas calculadas manualmente, ahora podemos implementar CostFunction:

class Rat43Analytic : public SizedCostFunction<1,4> {
    
    
   public:
     Rat43Analytic(const double x, const double y) : x_(x), y_(y) {
    
    }
     virtual ~Rat43Analytic() {
    
    }
     virtual bool Evaluate(double const* const* parameters,
                           double* residuals,
                           double** jacobians) const {
    
    
       const double b1 = parameters[0][0];
       const double b2 = parameters[0][1];
       const double b3 = parameters[0][2];
       const double b4 = parameters[0][3];

       residuals[0] = b1 *  pow(1 + exp(b2 -  b3 * x_), -1.0 / b4) - y_;

       if (!jacobians) return true;
       double* jacobian = jacobians[0];
       if (!jacobian) return true;

       jacobian[0] = pow(1 + exp(b2 - b3 * x_), -1.0 / b4);
       jacobian[1] = -b1 * exp(b2 - b3 * x_) *
                     pow(1 + exp(b2 - b3 * x_), -1.0 / b4 - 1) / b4;
       jacobian[2] = x_ * b1 * exp(b2 - b3 * x_) *
                     pow(1 + exp(b2 - b3 * x_), -1.0 / b4 - 1) / b4;
       jacobian[3] = b1 * log(1 + exp(b2 - b3 * x_)) *
                     pow(1 + exp(b2 - b3 * x_), -1.0 / b4) / (b4 * b4);
       return true;
     }

    private:
     const double x_;
     const double y_;
 };

Es un código tedioso que es difícil de leer y tiene mucha redundancia. Entonces, en la práctica, almacenaríamos en caché algunas subexpresiones para mejorar su eficiencia, lo que daría como resultado lo siguiente:

class Rat43AnalyticOptimized : public SizedCostFunction<1,4> {
    
    
   public:
     Rat43AnalyticOptimized(const double x, const double y) : x_(x), y_(y) {
    
    }
     virtual ~Rat43AnalyticOptimized() {
    
    }
     virtual bool Evaluate(double const* const* parameters,
                           double* residuals,
                           double** jacobians) const {
    
    
       const double b1 = parameters[0][0];
       const double b2 = parameters[0][1];
       const double b3 = parameters[0][2];
       const double b4 = parameters[0][3];

       const double t1 = exp(b2 -  b3 * x_);
       const double t2 = 1 + t1;
       const double t3 = pow(t2, -1.0 / b4);
       residuals[0] = b1 * t3 - y_;

       if (!jacobians) return true;
       double* jacobian = jacobians[0];
       if (!jacobian) return true;

       const double t4 = pow(t2, -1.0 / b4 - 1);
       jacobian[0] = t3;
       jacobian[1] = -b1 * t1 * t4 / b4;
       jacobian[2] = -x_ * jacobian[1];
       jacobian[3] = b1 * log(t2) * t3 / (b4 * b4);
       return true;
     }

   private:
     const double x_;
     const double y_;
 };

¿Cómo difieren estas dos implementaciones en el rendimiento?

CostoFunción	Tiempo (ns)
Rat43Analítico	255
Rat43AnalyticOptimized	92

Rat43AnalyticOptimized2,8 veces más rápido que Rat43Analytic. Esta diferencia en el tiempo de ejecución no es infrecuente. Para obtener el mejor rendimiento de las derivadas calculadas analíticamente, a menudo es necesario optimizar el código para tener en cuenta las subexpresiones comunes.

¿Cuándo se deben utilizar los derivados analíticos?

1. La expresión es simple, por ejemplo, mayormente lineal
2. Se puede usar un sistema de álgebra computacional como Maple, Mathematica o symy para diferenciar simbólicamente las funciones objetivo y generar c++ para calcularlas.
3. Hay algunas estructuras algebraicas en la fórmula que pueden lograr un mejor rendimiento que la diferenciación automática.
Dicho esto, obtener el máximo rendimiento fuera de calcular el recíproco es bastante trabajo.Antes de seguir este camino, es útil estimar que el costo computacional del jacobiano es una fracción del tiempo total de solución, recuerde que la ley de Live Amdahl es tu amigo.
4. No hay otra forma de calcular la derivada, por ejemplo quieres calcular la derivada de las raíces de un polinomio:
$a_3(x,y)z^3 + a_2(x,y)z^2 + a_1(x,y)z + a_0(x,y) = 0$

Para x, y, esto requiere el uso del teorema de la función inversa
5. Te gusta la regla de la cadena y haces cálculos algebraicos a mano.

Ceres introducción y ejemplos (8) Sobre Derivados (Derivados Analíticos)

Supongo que te gusta