激活函数比较：

1、sigmoid 函数除非在二元类输出层，不然千万不要用。 g‘（z）=g(z)*(1-g(z))---------a(1-a)

2、tanh 函数几乎在各种情况下都可以用。                         g'(z)=1-(g(z))**2---------------1-a**2

3、ReLU函数 是默认的函数。                                              if z<0 g'(z)=0  if z>0 g'(z)=1

4、泄漏的ReLU函数 。                  g(z)=max(0.01z,z)       if z<0 g'(z)=0.01 if z>=0 g'(z)=1

dj

简单的logistic算法实现：

import numpy as np

class logistic (object):

    def __init__(self,trains,labels,tests,tests_labels):

        self.trains=trains            #训练集

        self.labels=labels            #训练集标签

        self.tests=tests              #测试集

        self.tests_labels=tests_labels  #测试集标签

        self.weights=np.random.randn(trains.shape[0],1)    #初始化权重

        self.bias=np.random.randn(1,1)                    #初始化b

        self.rate=0.0001                                #默认学习率

        self.sample_size=self.trains.shape[1]        #m

    def train(self,epoch=500):

        for i in range(epoch):

            z=np.dot(self.weights.T,self.trains)+self.bias    #正向传播

            a=logistic.activation_function(z)

            dz=a-self.labels                                      #反向传播

            dw=(1/self.sample_size)*np.dot(self.trains,dz.T)

            db=(1/self.sample_size)*np.sum(dz)

            self.rate=2/(1.0+i)+0.0001                        #简单的动态更改学习率

            self.weights=self.weights-self.rate*dw

            self.bias=self.bias-self.rate*db

            print('第{i}次循环'.format(i=i))

        z=np.dot(self.weights.T,self.trains)+self.bias            #测试

        a=logistic.activation_function(z)

        print(a)

    def activation_function(z):

        return (np.exp(z)-np.exp(-z))/(np.exp(z)+np.exp(-z))      #tanh激活函数

        # return 1/(1+np.exp(-z))                                  #sigmoid 激活函数

if __name__=='__main__':

    train=np.random.randn(20,10)

    labels=np.array([1,0,1,0,1,1,1,0,0,0]).reshape(1,10)

    log=logistic(train,labels,None,None)

    log.train()