自適應線性神經元（Adline）

2019-08-26

 Adline算法屬性：監督算法，分類算法

1.算法框架

1.1凈輸入函數

 凈輸入函數：

 $z = w_{0}x_{0} + w_{1}x_{1} + ··· +w_{n}x_{n}={\sum_{j=0}^{n}}w_{j}x_{j}=w^{T}x$

其中x0的值為1，是函數的偏移量;在實際程序中可以使用兩種方式實現凈輸入函數：

1）在訓練數據X中添加值全部為1的列，作為偏移量的乘子；

2）將參數W中的第一個w0單獨提出來另算

用python實現，這里使用第二種方式

#凈輸入函數
def net_input(x,w):
    return np.dot(x,w[1:]) + w[0]

1.2激勵函數

Adline算法的激勵函數使用恆等函數，即：

$\phi(z)=z$

1.3量化器

$y=\left\{\begin{matrix}
1,\phi(z)\geq 0\\
-1,\phi(z)< 0
\end{matrix}\right.$

 使用python實現：

#量化器
def quantization(z):
    return np.where(z >= 0.0,1,-1)

 

2.代價函數

代價函數一般是為了反映模型與測試數據的擬合程度，

這里使用誤差平方和（SSE）作為Logistic Regression算法的代價函數：

$J(w) = \frac{1}{2} \sum_{i}(y^{(i)}-\phi(z^{(i)}))^{2}$

使用python實現：

#代價函數
#predict是數據的預測值，y是數據的實際值
def cost_function(predict,y):
    return ((y - predict)**2).sum() / 2.0

 

3.優化算法

gradient descent：

代價函數滿足1）可導，2）凸函數，才適合使用梯度下降法；

梯度下降法是基於代價函數J(w)沿着其梯度（即導數）方向做一次權重更新：

$w:=w+\Delta w$

$\Delta w = -\eta \frac{\partial J}{\partial w}$

$\frac{\partial J}{\partial w_{j}}=-\sum_{i}^{n}(y^{(i)}-\phi (z^{(i)}))x^{(i)}_{j}$

 其中$-\eta$ 表示梯度下降法的學習速率，$x^{(i)}_{j}$代表第i個數據的第j個值。

 由於每次權重迭代都是居於全部的測試數據，故此算法也稱為“批量梯度下降法”（batch gradient descent）；

 

4.權重迭代停止條件

1）設置一個最大迭代次數

2）設置一個代價函數的閾值，當某次訓練中實際得出的代價函數低於閾值時停止迭代

主要靠經驗獲取這兩個條件。

 

5.數據的標准化

按照每一列單獨處理的方式，將每一列數據轉換為方差為1，均值為0 的數據；數據標准化后訓練過程比較容易收斂。

$x^{'}_{j}=\frac{x_{j}-u_{j}}{\sigma _{j}}$

用python實現：

#數據標准化
def standard(X):
    X_std = np.copy(X)
    m,n = X_std.shape

    for i in range(n):
        X_std[:,i] = (X[:,i] - (X[:,i].mean()) / X[:,i].std()
    
    return X_std

 

6.以鳶尾花數據實現的Adline算法

'''自適應神經元，用於分類
Version = V.0.0'''

import numpy as np

class AdlineGD(object):
    """AdlineGD Classifier"""
    def __init__(self,eta=0.01,n_iter=50):
        self.eta = eta
        self.n_iter = n_iter

    #訓練函數
    def fit(self,X,y):
        self.w_ = np.zeros(X.shape[1])
        self.b_ = np.zeros(1)
        self.cost_ = []

        for _ in range(self.n_iter):
            output = self.net_input(X)
            errors = y - output
            cost = (errors**2).sum()/2.0
            self.cost_.append(cost)
            self.w_ += self.eta * np.dot(X.T,errors)
            self.b_ += self.eta * errors.sum()
        return self


    #神經元輸出
    def net_input(self,x):
        return np.dot(x,self.w_) + self.b_

    #激活函數
    def activation(self,x):
        return self.net_input(x)

    #預測函數
    def predict(self,x):
        return np.where(self.activation(x) > 0.0,1,-1)

 

更多內容可參考：github地址