统计学习方法中算法实现（基于Python）--- 感知机及SGD、BGD、MBGD的区别

1．感知机是根据输入实例的特征向量$x$对其进行二类分类的线性分类模型：

$$f(x)=\mathrm{sign}(w\cdot x+b)$$
感知机模型对应于输入空间（特征空间）中的分离超平面$w\cdot x+b=0$。

2．感知机学习的策略是极小化损失函数：

$$\underset{w,b}{\min }L(w,b)=-\sum _{x_i\in M}{y}_i\left(w\cdot x_i+b\right)$$
损失函数对应于误分类点到分离超平面的总距离。

3．感知机学习算法是基于随机梯度下降法的对损失函数的最优化算法，有原始形式和对偶形式。算法简单且易于实现。原始形式中，首先任意选取一个超平面，然后用梯度下降法不断极小化目标函数。在这个过程中一次随机选取一个误分类点使其梯度下降。

4．当训练数据集线性可分时，感知机学习算法是收敛的。感知机算法在训练数据集上的误分类次数$k$满足不等式：

$$k⩽{\left(\frac{R}{\gamma }\right)}^2$$
当训练数据集线性可分时，感知机学习算法存在无穷多个解，其解由于不同的初值或不同的迭代顺序而可能有所不同。

二分类模型
$f(x)=sign(w\cdot x+b)$

sign符号函数，x >= 0时，函数值+1，x < 0时，函数值为-1
给定训练集：

T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , ⋯ &ThinSpace; , ( x N , y N ) } T=\left\{\left(x_{1}, y_{1}\right),\left(x_{2}, y_{2}\right), \cdots,\left(x_{N}, y_{N}\right)\right\} T={(x1​,y1​),(x2​,y2​),⋯,(xN​,yN​)}

定义感知机的损失函数

$L(w,b)=-{\sum }_{x_i\in M}{y}_i\left(w\cdot x_i+b\right)$

算法
随即梯度下降法 Stochastic Gradient Descent

随机抽取一个误分类点使其梯度下降。

$w=w+\eta y_i{x}_i$

$b=b+\eta y_i$

当实例点被误分类，即位于分离超平面的错误侧，则调整$w$, $b$的值，使分离超平面向该无分类点的一侧移动，直至误分类点被正确分类

关于SGD、BGD、MBGD

BGD：

BGD 采用整个训练集的数据来计算 cost function 对参数的梯度：

$缺点：$

由于这种方法是在一次更新中，就对整个数据集计算梯度，所以计算起来非常慢，遇到很大量的数据集也会非常棘手，而且不能投入新数据实时更新模型。

for i in range(nb_epochs):
  params_grad = evaluate_gradient(loss_function, data, params)
  params = params - learning_rate * params_grad

我们会事先定义一个迭代次数 epoch，首先计算梯度向量 params_grad，然后沿着梯度的方向更新参数 params，learning rate 决定了我们每一步迈多大。
Batch gradient descent 对于凸函数可以收敛到全局极小值，对于非凸函数可以收敛到局部极小值。

SGD:

和 BGD 的一次用所有数据计算梯度相比，SGD 每次更新时对每个样本进行梯度更新，对于很大的数据集来说，可能会有相似的样本，这样 BGD 在计算梯度时会出现冗余，而 SGD 一次只进行一次更新，就没有冗余，而且比较快，并且可以新增样本。

for i in range(nb_epochs):
  np.random.shuffle(data)
  for example in data:
    params_grad = evaluate_gradient(loss_function, example, params)
    params = params - learning_rate * params_grad

整体数据集是个循环，其中对每个样本进行一次参数更新。
随机梯度下降是通过每个样本来迭代更新一次，如果样本量很大的情况，那么可能只用其中部分的样本，就已经将theta迭代到最优解了，对比上面的批量梯度下降，迭代一次需要用到十几万训练样本，一次迭代不可能最优，如果迭代10次的话就需要遍历训练样本10次。缺点是SGD的噪音较BGD要多，使得SGD并不是每次迭代都向着整体最优化方向。所以虽然训练速度快，但是准确度下降，并不是全局最优。虽然包含一定的随机性，但是从期望上来看，它是等于正确的导数的。

$缺点：$
SGD 因为更新比较频繁，会造成 cost function 有严重的震荡。
BGD 可以收敛到局部极小值，当然 SGD 的震荡可能会跳到更好的局部极小值处。
当我们稍微减小 learning rate，SGD 和 BGD 的收敛性是一样的。

MBGD：

MBGD 每一次利用一小批样本，即 n 个样本进行计算，这样它可以降低参数更新时的方差，收敛更稳定，另一方面可以充分地利用深度学习库中高度优化的矩阵操作来进行更有效的梯度计算。

和 SGD 的区别是每一次循环不是作用于每个样本，而是具有 n 个样本的批次。

for i in range(nb_epochs):
  np.random.shuffle(data)
  for batch in get_batches(data, batch_size=50):
    params_grad = evaluate_gradient(loss_function, batch, params)
    params = params - learning_rate * params_grad

$缺点：$
1、 Mini-batch gradient descent 不能保证很好的收敛性，learning rate 如果选择的太小，收敛速度会很慢，如果太大，loss function 就会在极小值处不停地震荡甚至偏离。（有一种措施是先设定大一点的学习率，当两次迭代之间的变化低于某个阈值后，就减小 learning rate，不过这个阈值的设定需要提前写好，这样的话就不能够适应数据集的特点。）对于非凸函数，还要避免陷于局部极小值处，或者鞍点处，因为鞍点周围的error是一样的，所有维度的梯度都接近于0，SGD 很容易被困在这里。（会在鞍点或者局部最小点震荡跳动，因为在此点处，如果是训练集全集带入即BGD，则优化会停止不动，如果是mini-batch或者SGD，每次找到的梯度都是不同的，就会发生震荡，来回跳动。）
2、 SGD对所有参数更新时应用同样的 learning rate，如果我们的数据是稀疏的，我们更希望对出现频率低的特征进行大一点的更新。LR会随着更新的次数逐渐变小。

import pandas as pd
import numpy as np
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt

iris=load_iris() # 加载数据
df=pd.DataFrame(iris.data,columns=iris.feature_names)
df['label']=iris.target

plt.scatter(df[:50]['sepal length (cm)'], df[:50]['sepal width (cm)'], label='0')
plt.scatter(df[50:100]['sepal length (cm)'], df[50:100]['sepal width (cm)'], label='1')
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.legend()

data_test=np.array(df.iloc[:100,[0,1,-1]])
x,y=data_test[:,:-1],data_test[:,-1]
y=np.array([1 if i == 1 else -1 for i in y])

class Perceptron:
    """
    构建感知机
    数据为线性可分数据
    一元一次线性方程
    """
    def __init__(self):
        self.w=np.ones(len(data_test[0])-1,dtype=np.float32)
        self.b=0
        self.lr=0.1
        
        
    def sign(self,w,x,b):
        # sign 函数
        y=np.dot(w,x)+b
        return 1 if y>=0 else -1 
    
    def fit(self,x_train,y_train):
        # 随机梯度下降
        is_wrong=False
        while not is_wrong:
            wrong_count=0
            for d in range(len(x_train)):
                x=x_train[d]
                y=y_train[d]
                if y*self.sign(self.w,x,self.b)<=0:
                    self.w=self.w+self.lr*np.dot(y,x)
                    self.b=self.b+self.lr*y
                    wrong_count+=1
            if wrong_count==0:
                is_wrong=True
        return 'Perceptron Model!'
    def score(self):
        pass

perceptron=Perceptron()
perceptron.fit(x,y)

# 画超平面
x_point=np.linspace(4,7,10)
y_point=-(perceptron.w[0] * x_point + perceptron.b) / perceptron.w[1]  # 此处超平面为 w0*x0+w1*x1+b=0,移项变换为 y=w*x+b 的形式
plt.plot(x_point,y_point)

plt.scatter(df[:50]['sepal length (cm)'], df[:50]['sepal width (cm)'], label='0')
plt.scatter(df[50:100]['sepal length (cm)'], df[50:100]['sepal width (cm)'], label='1')
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.legend()