参考资料

<PYTHON_MACHINE_LEARNING> chapter2
Training Ma
chine Learning Algorithms for Classifcation

引言

在上一节，我们学习了梯度下降算法，现在我们来了解一下梯度下降算法的一个类型——随机梯度下降，每一次更新只考虑一个样本的数据误差，所以速度很快，能进行在线的参数更新... ...

原理

基本原理与批量梯度下降算法相同，不同的是更新权值的方法
这是上一章节的权值更新方法

在随机梯度下降中，我们一次考虑一个样本的误差，再逐个加和，一旦到达最小，就可以停下来，所以可以大大加快模拟的速度，同时每一次迭代开始的时候，我们都打乱一遍训练集，为了减小样本之间造成的参数更新抵消问题

Python实现

我们在上一节AdalineGD类的基础上稍加改动就得到了AdalineSGD类
主要的改动有：

• 增加了一个洗牌(shuffle)方法，用于在每一次迭代开始的时候打乱训练集
• 增加了一个权值更新(._update_weights)方法, 用于更新每一个样本的误差

ok
上代码吧, 有什么问题都在注释里说明了

__author__ = 'Administrator'
#! /usr/bin/python <br> # -*- coding:utf8 -*-
import numpy as np
from numpy.random import seed
class AdalineSGD(object):
    """
    ADAlineSGD 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（时间起点）.
    shuffle: bool (default :True) 洗牌
    每次训练开始的时候将训练集重新打乱
    如果为真，阻止循环
    用随机数来 打乱数据集 并且初始化权值
    """

    def __init__(self, eta=0.01, n_iter=10,shuffle = True,
                 random_state = None):
        self.eta = eta
        self.n_iter = n_iter
        self.w_initialiezed = False
        self.shuffle = shuffle
        if random_state:
            seed(random_state)

    def _shuffle(self, X, y):
        """shuffle training data"""
        r = np.random.permutation(len(y))
        #random.permutation(array/number)
        #接受array的时候返回的是 array 的打乱的排列 ，
        # 接受 数字的时候 返回一个 range(number) 的打乱的排列
        # 所谓‘排列’可以理解成一个有数组序号组成的数组
        #X[r] 就是 X 按照 r 的排列重排的数组（只重排第一个索引（重排行）），
        # 同时 X[r] 返回一个copy 的对象
        #X 本身并没有改变
        #random.shuffle(array)不返回对象，重排array，改变array本身
        return X[r], y[r]

    def _initialize_weights(self, m):
        """Initialize weights to zeros"""
        self.w_ = np.zeros(1+m)
        #初始化之后把属性 w_initialiezd 设为 True
        self.w_initialiezed = True

    def fit(self, X, y):
        '''
    Fit training data.
    Parameters
    ----------
    X : {array-like}, shape = [n_samples, n_features] X的形式是列表的列表
    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._initialize_weights(X.shape[1])
        #将 权值属性self.w_初始化 (100,1)的0数组
        #X.shape = (100,2)
        self.cost_ =[]
        #self.cost_损失函数 cost_function
        for i in range(self.n_iter):
            #开始默认 shuffle为真
            if self.shuffle:
                X, y = self._shuffle(X,y)
            cost = []
            for xi,target in zip(X,y):
                cost.append(self._update_weights(xi,target))
            avg_cost = sum(cost)/len(y)
            #avg_cost = np.array(cost).mean()
            #也可用这种方法求平均数
            self.cost_.append(avg_cost)
        return self

    def partial_fit(self, X, y):
        """Fit training data  without reinitializing the weights"""
        if not self.w_initialiezed:
            self._initialize_weights(X.shape[1])
        if y.ravel().shape[0] > 1:
            for xi, target in zip(X, y):
                self._update_weights(xi,target)
        else:
            self._update_weights(X, y)
        return self




    def _update_weights(self, xi, target):
        """Apply Adaline learning rule to update the weights"""
        output = self.net_input(xi)
        error = (target - output)
        #每次error都是一个float
        #xi对应一个样本 (2,1)
        #wi 的 update = eta* xi[i]*error
        self.w_[1:] += self.eta * xi.dot(error)
        self.w_[0] += self.eta * error
        cost = 0.5 * error ** 2
        return cost

    def net_input(self, X):
        """Calculate net input"""
        #np.dot(A,B)表示矩阵乘法 ，X(100,2) self.w_[1:](2,1)
        #注意 这里每一组 向量x = [x1,x2] 不是 [x1,,,,,,x100]!!!
        #所以得到的 net_input 是(100,1)的矩阵 表示100个样本的net_input
        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.net_input(X) >= 0.0, 1, -1)

一样用鸢尾花 Iris 的数据集来验证一下

__author__ = 'Administrator'
#！/usr/bin/python <br> # -*- coding: utf8 -*-
from GDR import AdalineSGD
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
from PDC import plot_decision_regions
filename = 'Iris.csv'
df = pd.read_csv(filename,header=None)
y = df.iloc[0:100, 4].values # .values将dataframe中的值存进一个list中
y = np.where(y=='Iris-setosa',-1,1) #如果是 Iris-setosa y=-1否则就是1 （二元分类）
X = df.iloc[0:100,[0,2]].values
X_std = np.copy(X)
X_std[:,0] = (X[:,0]-X[:,0].mean())/ X[:,0].std() #.std() 标准差
X_std[:,1] = (X[:,1]-X[:,1].mean())/ X[:,1].std() #.std() 标准差
ada = AdalineSGD(n_iter=15, eta=0.01,random_state=1)
ada.fit(X_std, y)

plot_decision_regions(X_std, y, classifier=ada)
plt.title('Adaline - Stochastic Gradient Descent')
plt.xlabel('sepal length [standardized]')
plt.ylabel('petal length [standardized]')
plt.legend(loc='upper left')
plt.savefig('Adaline- Stochastic Gradient Descent.png')
plt.show()
plt.plot(range(1,len(ada.cost_)+1), ada.cost_, marker='o')
plt.xlabel('Epoches')
plt.ylabel('Average Cost')
plt.savefig('Average Cost - Epoches.png')
plt.show()

比较一下达到最优的速率
SGD

BGD

很明显 SGD 的收敛速率要快一点
OK!