Python | C++漂移扩散方程和无风险套利公式算法微分

本文主要是介绍Python | C++漂移扩散方程和无风险套利公式算法微分，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

🎯要点

🍇Python和C++计算微分正反向累积

算法微分在机器学习领域尤为重要。例如，它允许人们在神经网络中实现反向传播，而无需手动计算导数。

计算微分的基础是复合函数偏导数链式法则提供的微分分解。简单结构如：
$\begin{aligned} y & =f(g(h(x)))=f\left(g\left(h\left(w_0\right)\right)\right)=f\left(g\left(w_1\right)\right)=f\left(w_2\right)=w_3 \\ w_0 & =x \\ w_1 & =h\left(w_0\right) \\ w_2 & =g\left(w_1\right) \\ w_3 & =f\left(w_2\right)=y \end{aligned}$
由链式法则得出：
$\frac{\partial y}{\partial x}=\frac{\partial y}{\partial w_2} \frac{\partial w_2}{\partial w_1} \frac{\partial w_1}{\partial x}=\frac{\partial f\left(w_2\right)}{\partial w_2} \frac{\partial g\left(w_1\right)}{\partial w_1} \frac{\partial h\left(w_0\right)}{\partial x}$
通常，存在两种不同的计算微分模式：正向累积和反向累积。

正向累积指定从内到外遍历链式法则（即首先计算 $\partial w_1 / \partial x$ ，然后计算 $\partial w_2 / \partial w_1$ ，最后计算 $\partial y / \partial w_2$ ），而反向累积是从外到内的遍历（首先计算 $\partial y / \partial w_2$ ，然后计算 $\partial w_2 / \partial w_1$ ，最后计算 $\partial w_1 / \partial x$ ）。更简洁地说，

正向累积计算递归关系： $\frac{\partial w_i}{\partial x}=\frac{\partial w_i}{\partial w_{i-1}} \frac{\partial w_{i-1}}{\partial x}$ 且 $w_3=y$

反向累积计算递归关系： $\frac{\partial y}{\partial w_i}=\frac{\partial y}{\partial w_{i+1}} \frac{\partial w_{i+1}}{\partial w_i}$ 且 $w_0=x$

正向累积在一次传递中计算函数和导数（但每个仅针对一个独立变量）。相关方法调用期望表达式 Z 相对于变量 V 导出。该方法返回一对已求值的函数及其导数。该方法递归遍历表达式树，直到到达变量。如果请求相对于此变量的导数，则其导数为 1，否则为 0。然后求偏函数以及偏导数。

伪代码：

tuple<float,float> evaluateAndDerive(Expression Z, Variable V) {if isVariable(Z)if (Z = V) return {valueOf(Z), 1};else return {valueOf(Z), 0};else if (Z = A + B){a, a'} = evaluateAndDerive(A, V);{b, b'} = evaluateAndDerive(B, V);return {a + b, a' + b'};else if (Z = A - B){a, a'} = evaluateAndDerive(A, V);{b, b'} = evaluateAndDerive(B, V);return {a - b, a' - b'};else if (Z = A * B){a, a'} = evaluateAndDerive(A, V);{b, b'} = evaluateAndDerive(B, V);return {a * b, b * a' + a * b'};
}

Python实现正向累积：

class ValueAndPartial:def __init__(self, value, partial):self.value = valueself.partial = partialdef toList(self):return [self.value, self.partial]class Expression:def __add__(self, other):return Plus(self, other)def __mul__(self, other):return Multiply(self, other)class Variable(Expression):def __init__(self, value):self.value = valuedef evaluateAndDerive(self, variable):partial = 1 if self == variable else 0return ValueAndPartial(self.value, partial)class Plus(Expression):def __init__(self, expressionA, expressionB):self.expressionA = expressionAself.expressionB = expressionBdef evaluateAndDerive(self, variable):valueA, partialA = self.expressionA.evaluateAndDerive(variable).toList()valueB, partialB = self.expressionB.evaluateAndDerive(variable).toList()return ValueAndPartial(valueA + valueB, partialA + partialB)class Multiply(Expression):def __init__(self, expressionA, expressionB):self.expressionA = expressionAself.expressionB = expressionBdef evaluateAndDerive(self, variable):valueA, partialA = self.expressionA.evaluateAndDerive(variable).toList()valueB, partialB = self.expressionB.evaluateAndDerive(variable).toList()return ValueAndPartial(valueA * valueB, valueB * partialA + valueA * partialB)# Example: Finding the partials of z = x * (x + y) + y * y at (x, y) = (2, 3)
x = Variable(2)
y = Variable(3)
z = x * (x + y) + y * y
xPartial = z.evaluateAndDerive(x).partial
yPartial = z.evaluateAndDerive(y).partial
print("∂z/∂x =", xPartial)  # Output: ∂z/∂x = 7
print("∂z/∂y =", yPartial)  # Output: ∂z/∂y = 8

C++实现正向累积：

#include <iostream>
struct ValueAndPartial { float value, partial; };
struct Variable;
struct Expression {virtual ValueAndPartial evaluateAndDerive(Variable *variable) = 0;
};
struct Variable: public Expression {float value;Variable(float value): value(value) {}ValueAndPartial evaluateAndDerive(Variable *variable) {float partial = (this == variable) ? 1.0f : 0.0f;return {value, partial};}
};
struct Plus: public Expression {Expression *a, *b;Plus(Expression *a, Expression *b): a(a), b(b) {}ValueAndPartial evaluateAndDerive(Variable *variable) {auto [valueA, partialA] = a->evaluateAndDerive(variable);auto [valueB, partialB] = b->evaluateAndDerive(variable);return {valueA + valueB, partialA + partialB};}
};
struct Multiply: public Expression {Expression *a, *b;Multiply(Expression *a, Expression *b): a(a), b(b) {}ValueAndPartial evaluateAndDerive(Variable *variable) {auto [valueA, partialA] = a->evaluateAndDerive(variable);auto [valueB, partialB] = b->evaluateAndDerive(variable);return {valueA * valueB, valueB * partialA + valueA * partialB};}
};
int main () {// Example: Finding the partials of z = x * (x + y) + y * y at (x, y) = (2, 3)Variable x(2), y(3);Plus p1(&x, &y); Multiply m1(&x, &p1); Multiply m2(&y, &y); Plus z(&m1, &m2);float xPartial = z.evaluateAndDerive(&x).partial;float yPartial = z.evaluateAndDerive(&y).partial;std::cout << "∂z/∂x = " << xPartial << ", "<< "∂z/∂y = " << yPartial << std::endl;// Output: ∂z/∂x = 7, ∂z/∂y = 8return 0;
}

反向累积需要两次传递：在正向传递中，首先评估函数并缓存部分结果。在反向传递中，计算偏导数并反向传播先前导出的值。相应的方法调用期望表达式 Z 被导出，并以父表达式的导出值为种子。对于顶部表达式 Z 相对于 Z 导出，这是 1。该方法递归遍历表达式树，直到到达变量并将当前种子值添加到导数表达式。

伪代码：

void derive(Expression Z, float seed) {if isVariable(Z)partialDerivativeOf(Z) += seed;else if (Z = A + B)derive(A, seed);derive(B, seed);else if (Z = A - B)derive(A, seed);derive(B, -seed);else if (Z = A * B)derive(A, valueOf(B) * seed);derive(B, valueOf(A) * seed);
}

Python实现反向累积：

class Expression:def __add__(self, other):return Plus(self, other)def __mul__(self, other):return Multiply(self, other)class Variable(Expression):def __init__(self, value):self.value = valueself.partial = 0def evaluate(self):passdef derive(self, seed):self.partial += seedclass Plus(Expression):def __init__(self, expressionA, expressionB):self.expressionA = expressionAself.expressionB = expressionBself.value = Nonedef evaluate(self):self.expressionA.evaluate()self.expressionB.evaluate()self.value = self.expressionA.value + self.expressionB.valuedef derive(self, seed):self.expressionA.derive(seed)self.expressionB.derive(seed)class Multiply(Expression):def __init__(self, expressionA, expressionB):self.expressionA = expressionAself.expressionB = expressionBself.value = Nonedef evaluate(self):self.expressionA.evaluate()self.expressionB.evaluate()self.value = self.expressionA.value * self.expressionB.valuedef derive(self, seed):self.expressionA.derive(self.expressionB.value * seed)self.expressionB.derive(self.expressionA.value * seed)# Example: Finding the partials of z = x * (x + y) + y * y at (x, y) = (2, 3)
x = Variable(2)
y = Variable(3)
z = x * (x + y) + y * y
z.evaluate()
print("z =", z.value)        # Output: z = 19
z.derive(1)
print("∂z/∂x =", x.partial)  # Output: ∂z/∂x = 7
print("∂z/∂y =", y.partial)  # Output: ∂z/∂y = 8

C++实现反向累积：

#include <iostream>
struct Expression {float value;virtual void evaluate() = 0;virtual void derive(float seed) = 0;
};
struct Variable: public Expression {float partial;Variable(float _value) {value = _value;partial = 0;}void evaluate() {}void derive(float seed) {partial += seed;}
};
struct Plus: public Expression {Expression *a, *b;Plus(Expression *a, Expression *b): a(a), b(b) {}void evaluate() {a->evaluate();b->evaluate();value = a->value + b->value;}void derive(float seed) {a->derive(seed);b->derive(seed);}
};
struct Multiply: public Expression {Expression *a, *b;Multiply(Expression *a, Expression *b): a(a), b(b) {}void evaluate() {a->evaluate();b->evaluate();value = a->value * b->value;}void derive(float seed) {a->derive(b->value * seed);b->derive(a->value * seed);}
};
int main () {// Example: Finding the partials of z = x * (x + y) + y * y at (x, y) = (2, 3)Variable x(2), y(3);Plus p1(&x, &y); Multiply m1(&x, &p1); Multiply m2(&y, &y); Plus z(&m1, &m2);z.evaluate();std::cout << "z = " << z.value << std::endl;// Output: z = 19z.derive(1);std::cout << "∂z/∂x = " << x.partial << ", "<< "∂z/∂y = " << y.partial << std::endl;// Output: ∂z/∂x = 7, ∂z/∂y = 8return 0;
}