自動求導程序的設計與實現（Python)

動機

作者 Yangtf

最近一直在求各種導數，於是就想寫一個自動求導的算法。 其實python中的theano就有這個功能，但想了想，思路不難，於是就動手實現了一個。

本來想用c++實現了，但發現c++寫各種問題，內存管理、操作符重載都不盡人意。花費了不少時間後，決定換語言。 Java是第一熟練語言，但不支持操作符重載，奈何？ 於是轉戰python。

源代碼路徑

最新的源代碼在這裏。
http://git.oschina.net/yangtf/python_exp

思路

函數的表示

將函數表達式表示爲一個表達式樹。

那個這個表達式樹如何構建呢？　要自己寫語法分析麼？　太麻煩，有種比較簡單的辦法，就是使用操作符重載來實現。

定義一個類Ｅ，重載它的 + - * / **（乘方）操作，在重載中，進行二叉樹的構建。

節點類型

在這個表達式樹中，主要應有三種節點類型。
其一，常數節點。如 2，3
其二，變量節點，如 a,b,x,y之類。
其三，操作節點。如 + , - ,* , / ,乘方等。

求導方法

有了表達式構成的二叉樹，下面就是求導了。

對常數節點求導，結果爲0 。
對變量節點求導，有兩種情況。如

f(a,b)=a2+3b

這個函數對a 求偏導，那麼就將b節點看成是一個常數,求導結果爲0。
對於保存了a的節點，求導結果爲1。

求導的方法就是那些求導公式，舉例：

(x+y)′=x′+y′

求導看這篇文章 http://blog.csdn.net/taiji1985/article/details/72857554

上面的公式，對於一個根爲‘+’的二叉樹，分別對其左子樹和 右子樹進行求導，然後將求導得到的和相加。

那麼如何求導左子樹呢？，遞歸的調用這個求導方法就可以了。

對乘方節點的處理時比較難的。

先對左子樹f求導，對右子樹g求導。
如果f求導爲0，說明是指數函數 ，如果g求導爲0，說明是冪函數，分別套用公式。
至於f(x)g(x) 這種形式，求導公式有點複雜，還要去請教一些數學方面的高手。還沒有做。

化簡

求導不是最難的，最難的是化簡。 比如對 1 / ( 1 + e ^ ( - ( w * x + b ) ) ) 按照上述算法求導，得到的結果是：

( 0 * ( 1 + e ^ ( - ( w * x + b ) ) ) - 1 * ( 0 + e ^ ( - ( w * x + b ) ) * 1 * ( 0 * ( w * x + b ) + - ( 1 * x + w * 0 + 0 ) ) ) ) / ( 1 + e ^ ( - ( w * x + b ) ) ) * ( 1 + e ^ ( - ( w * x + b ) ) )

這就需要化簡。我實現了化簡的幾個思路：

（1） 0+x，x+0 x-0 這種化簡爲 x 。0*x x*0 0/x 化簡爲 0

在上圖中， 左圖c節點爲0，則應讓a直接指向d。刪除c和b節點。 右圖爲1*x的圖，應讓a直接指向d。
（2）x*1 1*x x/1 這種直接簡化爲x
（3） 兩個常量進行運算，F+F， F-F， F*F， F/F 都簡化爲單一節點。
（4） 較爲複雜的節點合併。

在上圖中，右子樹有個3， 左子樹有一個4，算法

如果右子樹是一個常量節點，則在左子樹中查找與p指向節點符號相同的節點。 經過三個星號，找到了4，然後3*4 ->12 ,隨後刪除原本p指向的節點，讓p直接指向原本的左子樹。

(5) x∗x=>x2

(6) 0−x=>−1∗x

(7) x^1 => x

(8) log e - > 1

代碼實現

# -*- coding: UTF-8 -*-

'''
Created on 2017-6-8

@author: Administrator

二元運算符    特殊方法
+    __add__,__radd__
-    __sub__,__rsub__
*    __mul__,__rmul__
/    __div__,__rdiv__,__truediv__,__rtruediv__
//    __floordiv__,__rfloordiv__
%    __mod__,__rmod__
**    __pow__,__rpow__
<<    __lshift__,__rlshift__
>>    __rshift__,__rrshift__
&    __and__,__rand__
^    __xor__,__rxor__
|    __or__,__ror__
+=    __iaddr__
-=    __isub__
*=    __imul__
/=    __idiv__,__itruediv__
//=    __ifloordiv__
%=    __imod__
**=    __ipow__
<<=    __ilshift__
>>=    __irshift__
&=    __iand__
^=    __ixor__
|=    __ior__
==    __eq__
!=,<>    __ne__
>    __get__
<    __lt__
>=    __ge__
<=    __le__

'''

class E:
    def __init__(self):
        self.left=None;
        self.right=None;
        self.parent = None;
        self.type = 'n';
        self.f = 0;
        pass
    def isOp(self,op):
        return self.type == 'op' and self.f == op;

    def isZero(self):
        return self.type == 'float' and abs(self.f) < 1e-5;
    def isOne(self):
        return self.type == 'float' and abs(self.f -1 ) < 1e-5;
    def isNum(self):
        return self.type == 'float';
    def float(self,a): #
        self.f = a;
        self.left = self.right = None;
        self.type = 'float';
        return self;
    def sym(self,name): 
        self.type = 'sym';
        self.f = name;
        return self;
    def withOp(self,op,left,right):
        self.f = op;
        self.type = 'op';

        if type(left) == int or type(left) == float:
            left = E().float(left);

        if type(right) == int or type(right) == float:
            right = E().float(right);

        if left != None:
            self.left = left.clone();
            self.left.parent = self;
        else:
            self.left =None;
        if right != None:
            self.right = right.clone();
            self.right.parent = self;
        else:
            self.right = None;
        return self;
    def clone(self): #深度複製
        x = E();
        x.type = self.type;
        x.f = self.f;
        if self.left == None:
            x.left = None;
        else:
            x.left = self.left.clone();

        if self.right == None:
            x.right = None;
        else:
            x.right = self.right.clone();
        return x;

    def __radd__(self,x):
        #print '__radd__ ',x
        r = E().withOp('+', x,self);
        return r;
    def __rsub__(self,x):
        #print '__rsub__ ',x
        r = E().withOp('-', x,self);
        return r;
    def __rmul__(self,x):
        r = E().withOp('*', x,self);
        return r;
    def __rdiv__(self,x):
        r = E().withOp('/', x,self);
        return r;
    def __neg__(self):          
        r = E().withOp('*', E().float(-1),self);
        return r;
    def __add__(self,x):
        #print 'add ',x
        r = E().withOp('+', self, x);
        return r;
    def __sub__(self,x):
        r = E().withOp('-', self, x);
        return r;
    def __mul__(self,x):
        r = E().withOp('*', self, x);
        return r;
    def __div__(self,x):
        r = E().withOp('/', self, x);
        return r;
    def __pow__(self,x):
        r = E().withOp('^', self, x);
        return r;

    def isConstOf(self,x): # 求導時，對於x是否是一個常數
        if self.type == 'float':
            return True;
        if self.type == 'sym' :
            return self.f == x.f;

        return (self.left == None or self.left.isConstOf(x)) and (self.right == None or self.right.isConstOf(x));

    def op_diff(self,x):
        # do something with None left or right
        if self.left == None:
            d_left =None;
        else:
            d_left = self.left.diff(x);
        if self.right == None:
            d_right = None;
        else:
            d_right = self.right.diff(x);

        if self.f == '+':
            return d_left+d_right;
        if self.f == '-':
            return d_left-d_right;
        if self.f == '*':
            return d_left*self.right+self.left*d_right;
        if self.f == '/':
            return (d_left*self.right-self.left*d_right)/(self.right*self.right);
        if self.f == '^':
            left_c = d_left == E().float(0);
            right_c = d_right == E().float(0);

            if left_c and right_c :
                return E().float(0);
            elif right_c: # f(x)^a  ()' = a*f(x)^(a-1)*f'(x);
                return self.right*self.left**(self.right-1)*d_left;
            elif left_c: #指數 a^g(x)  ()' = a^g(x)*loga*g'(x)
                return self.left**self.right * self.left.log() * d_right;
            else:
                print 'unsupport f(x)^g(x) style!! now ' 
                exit(1);
        pass
    def diff(self,x): # 對x求偏導數
        if self.type == 'float':
            return E().float(0);
        elif self.type == 'sym':
            if x.f == self.f: # 是同一個變量
                return E().float(1);
            else:
                return E().float(0); #不是同一個變量。
        elif self.type == 'op':
            return self.op_diff(x);


        pass
    def eq(self,x,y):
        if x == None :
            return y == None;
        else :
            return x == y;
    def __eq__(self,x):
        if x == None:
            return False;
        if x.type != self.type:
            return False;
        if x.type == 'float':
            return abs(x.f - self.f)<1e-5;
        if x.type == 'sym':
            return x.f == self.f;
        if x.type == 'op':
            if x.f != self.f :
                return False;
            return self.eq(self.left,x.left) and self.eq(self.right,x.right);
    def printme(self):
        self.setParent();
        self._printme();
        print '';
    def _op_toi(self,op):
        if op == '+' or op == '-':
            return 10;
        if op == '*' or op == '/':
            return 20;
        if op == '^':
            return 30;
        return 40;
    def _compare_op(self,a,b): #比較兩個符號，誰的優先級高
        #print 'compare ',a,b,self._op_toi(a) - self._op_toi(b);
        return self._op_toi(a) - self._op_toi(b);
    def _printme(self):
        if self.type == 'float':
            print self.f ,;
        elif self.type == 'op':
            useBrack = True;
            if self.parent == None:
                useBrack = False;
            elif self._compare_op(self.f, self.parent.f)>= 0:
                useBrack = False;


            if useBrack:
                print '(',;
            #如果是 -1*x ，直接輸出 -x;
            if self.left !=None and self.left == E().float(-1) and self.isOp('*'):
                print '-',;
            else:
                if self.left !=None:
                    self.left._printme();
                print self.f ,;
            if self.right != None:
                self.right._printme();
            if useBrack:
                print ')',;
        elif self.type == 'sym':
            print self.f ,;
        pass


    def child_pattern(self,x):
        if x == None:
            return 'none';
        if x.left == None:
            lc= "N";
        elif x.left.isOne():
            lc = '1';
        elif x.left.isZero():
            lc = '0';
        elif x.left.type == 'float':
            lc = 'F';
        else:
            lc ='A';

        if x.right == None:
            rc= "N";
        elif x.right.isOne():
            rc = '1';
        elif x.right.isZero():
            rc = '0';
        elif x.right.type == 'float':
            rc = 'F';
        else :
            rc ='A';



        pt= str(lc)+str(x.f) + str(rc);
        #print "PT=",pt," -------------";
        #x.printme();

        return pt;


    def evalue(self,op,a,b):
        if op == '+':
            r= a.f+b.f;
        if op == '-':
            r= a.f-b.f;
        if op == '*':
            r= a.f*b.f;
        if op == '/':
            r= a.f/b.f;
        return r;

    def _node_op(self,r,op,v):
        # 在以r爲根的樹中，查找一個滿足從根r到該節點整條路徑上節點都與op相同的float節點，並將v中的數據應用op進去。
        if r == None :
            return False;
        if r.type == 'float' : # 如果當前節點就是一個float節點，把v的值乘在這裏。
            r.f = r.evalue(op,r,v);
            return True;

        if r.type != 'op' or r.f != op: #當前節點不滿足op相等條件
            return False;

        if self._node_op(r.left, op, v):
            return True;

        if self._node_op(r.right, op, v):
            return True;

        return False;

        pass
    def _node_join(self,r,x,y):
        #合併兩個節點 2+(2+x) => 4+x;
        #r 如果不能合併應返回的值
        #x 判斷x是否是一個數字，如果是，則看能否和y中節點合併
        if x==None or y == None or  x.type != 'float' :
            return r;

        succ = self._node_op(y, r.f, x); #如果成功將x乘進了y，則刪除x，把y作爲父。
        if succ:
            return y;
        return r;
        #在y中查找
#         if y.type == 'op' and y.type == r.type  and y.f == r.f:
#             if y.left != None and y.left.type=='float':
#                 y.left.f = self.evalue(y.f, x, y.left);
#                 
#                 return y;
#             if y.right != None and y.right.type=='float':
#                 y.right.f = self.evalue(y.f, x, y.right);
#                 return y;
#             
#        return r;

    def _opt_node(self,x):
        #左子樹 0,1檢測
        r = x;
        if x == None :
            return x;

        pt = self.child_pattern(x);
        if pt == 'F-1':
            pt = pt; # for debug

        if pt == '0*A' or pt == '0/A' or pt== 'A*0':
            r = E().float(0);
        if pt == '0+A' or pt == '0+1':
            r = x.right;
        if pt == 'A+0' or pt == '1+0':
            r = x.left;
        if pt == 'A*1':
            r = x.left;

        #左子樹常數化簡
        pt = self.child_pattern(x);
        pt = pt.replace('0', 'F').replace('1','F');
        #print '#####', pt;

        if pt == 'F+F':
            r = E().float(x.left.f+x.right.f);
        if pt == 'F-F':
            r = E().float(x.left.f-x.right.f);
        if pt == 'F*F':
            r = E().float(x.left.f*x.right.f);
        if pt == 'F/F':
            r = E().float(x.left.f/x.right.f);
        return r;
    def optm(self): # 優化式子
        # 後續遍歷，從下網上優化
        if self.left!= None:
            self.left = self.left.optm();
        if self.right!=None:
            self.right = self.right.optm();

        self.left = self._opt_node(self.left);
        self.right = self._opt_node(self.right);

        r = self._opt_node(self);

        # 0-x -> -1*x
        if self.isOp('-'):
            if self.left!=None and self.left == E().float(0):
                self.f = '*';
                self.left = E().float(-1);


        #優化常數項（多個常數項相乘，如2*3*x ->6*x)
        r = self._node_join(r,r.left,r.right);
        r = self._node_join(r,r.right,r.left);

        if r.left != None and r.left == r.right:
            if r.isOp('*'):
                r.f = '^';
                r.right = E().float(2);


        #優化乘方
        if r.isOp('^') and r.right != None and r.right.isOne():
            return r.left;


        return r;
        pass

    #求以e爲底的對數
    def log(self):
        if self.type == 'sym' and self.f == 'e':
            return E().float(1);
        r = E().withOp('log', None, self);
        return r;

    #設置所有parent指針

    def setParent(self):
        if self.left !=None :
            self.left.parent = self;
            self.left.setParent();
        if self.right != None:
            self.right.parent = self;
            self.right.setParent();
pass


# class Optmer:
#     def __init__(self):
#         pass
#     def addParentPointer(self,tree):
#         if tree.left != None:
#             tree.left.parent = tree;
#             self.addParentPointer(tree.left);
#         if tree.right != None:
#             tree.right.parent = tree;
#             self.addParentPointer(tree.right);
#         
#     def optNode(self,node):
#         self.addParentPointer(node);
# 
#     def _zeroOptNode(self,node):
#         if node == None:
#             return;
#         if node.isZero():
#             node.parent.
#         pass

x = E().sym('x');
#c = 2*x**2+3*x**4+E().float(4)**x;
e = E().sym('e');
w = E().sym('w');
b = E().sym('b');
c = 1/(1+e**(-(w*x+b)));
c.printme();

d = c.diff(w);
d.printme();
d.optm().optm().printme();

運行測試

以 sigmoid函數爲例，進行求導。

待求導的函數
1 / ( 1 + e ^ ( - ( w * x + b ) ) )

求導後，化簡前
( 0 * ( 1 + e ^ ( - ( w * x + b ) ) ) - 1 * ( 0 + e ^ ( - ( w * x + b ) ) * 1 * ( 0 * ( w * x + b ) + - ( 1 * x + w * 0 + 0 ) ) ) ) / ( 1 + e ^ ( - ( w * x + b ) ) ) * ( 1 + e ^ ( - ( w * x + b ) ) )
化簡後，中間還是有一個1在哪裏， 問題在哪裏太晚了，不查了。結果是對的。
e ^ ( - ( w * x + b ) ) * 1 * x / ( 1 + e ^ ( - ( w * x + b ) ) ) ^ 2

TODO

分數化簡