ML实践-Adaptive Linear Neurons（Adaline）

原理

在万事开头难那篇文中，介绍了一个初级的一层神经网，这是在最初级上面的follow up 版。
增强的点有：
1. Bernard新提出了cost function
2. weights的更新基于线性方程（linear activation function），而不是之前perceptron中的离散方程（unit step function）

Cost Function

Sum of Square Errors(SSE)
J(w)=12∑i(yi−ϕ(zi))2

其中ϕ(zi)为图中Activation function的输出，在此处简单定义为：
ϕ(wTx)=wTx

理想的状况是，目标方程是U型的。我们可以用梯度下降法找到最小的cost.

梯度下降gradient descent

η 为步长， 偏导结果为方向

feature scaling

当η过大时，会发生overshoot. 解决办法一个是减小它的大小，另外一种办法是特征缩放。在此次实验中用的是标准化的方法缩小特征值。

实现

import numpy as npclass AdalineGD(object):    """ADAptive LInear NEuron classifier.    Parameters    -----------    eta : float    Learning rate (between 0.0 and 1.0)    n_iter : int    Passes over the training dataset.    Attributes    -----------    w_ : 1d-array    Weights after fitting.    errors_ : list    Number of misclassifications in every epoch.    """    def __init__(self, eta=0.01, n_iter=50):        self.eta = eta        self.n_iter = n_iter    def fit(self, X, y):    """ Fit training data.    Parameters    ----------    X : {array-like}, shape = [n_samples, n_features]        Training vectors, where n_samples is the number of samples and        n_features is the number of features.    y : array-like, shape = [n_samples]Target values.    Returns    -------    self : object    """        self.w_ = np.zeros(1 + X.shape[1])        self.cost_ = []        for i in range(self.n_iter):            output = self.net_input(X)            errors = (y - output)            #X.T.dot 叉乘 output：向量            self.w_[1:] += self.eta * X.T.dot(errors)            self.w_[0] += self.eta * errors.sum()            cost = (errors**2).sum() / 2.0            self.cost_.append(cost)        return self    def net_input(self, X):    """Calculate net input"""        #np.dot 点乘 output:标量        return np.dot(X, self.w_[1:]) + self.w_[0]    def activation(self, X):    """Compute linear activation"""        return self.net_input(X)    def predict(self, X):    """Return class label after unit step"""        return np.where(self.activation(X) >= 0.0, 1, -1)

重点是weight的更新：

self.w_[1:] += self.eta * X.T.dot(errors)self.w_[0] += self.eta * errors.sum()

和新添的activation function

def activation(self, X):    """Compute linear activation"""    return self.net_input(X)

测试

>>> fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(8, 4))>>> ada1 = AdalineGD(eta=0.01, n_iter=50).fit(X, y)>>> ax[0].plot(range(1, len(ada1.cost_) + 1),... np.log10(ada1.cost_), marker='o')>>> ax[0].set_xlabel('Epochs')>>> ax[0].set_ylabel('log(Sum-squared-error)')>>> ax[0].set_title('Adaline - Learning rate 0.01')>>> ada2 = AdalineGD(eta=0.0001, n_iter=50).fit(X, y)>>> ax[1].plot(range(1, len(ada2.cost_) + 1),... ada2.cost_, marker='o')>>> ax[1].set_xlabel('Epochs')>>> ax[1].set_ylabel('Sum-squared-error')>>> ax[1].set_title('Adaline - Learning rate 0.0001')>>> plt.show()

左图中，因为learning rate步长太大，发生了overshoot,所以最后没有降下来。
通过feature scaling, 在此也就是标准化特征：

#减去平均数，除以标准差>>> X_std = np.copy(X)>>> X_std[:,0] = (X[:,0] - X[:,0].mean()) / X[:,0].std()>>> X_std[:,1] = (X[:,1] - X[:,1].mean()) / X[:,1].std()

再将模型fit函数输入改为x_std:

ada.fit(X_std, y)