自适应线性神经元（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{egin{matrix}
1,phi(z)geq 0\
-1,phi(z)< 0
end{matrix} ight.$

使用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)

View Code

更多内容可参考：github地址