感知机模型

感知机模型的对偶形式
感知机是一种判别模型，使用于二分类问题，输入为实例的特征向量，输出实例的类别；取-1和+1分被称为负类和正类。。感知机学习主要是求出将训练数据能够进行线性划分的分离超平面，所以就有了基于误分类的损失函数，利用梯度下降法对损失函 数进行极小化，求得感知机模型 感知机学习算法具有简单而易于实现的优点，分为 原始形式和对偶形式 。

首先我们来看看感知机模型

模型：由输入空间到输出空间的如下函数：
$$f(x)=sign(w•x+b)$$
sign()为符号函数 ；

w,b:为模型参数（w : 权值或权值向量，b：偏置常量，w•x ：内积（向量相乘再求和）

为得到 S ，即确定模型参数w,b,定义损失函数并极小化

损失函数：在感知机模型中损失函数的一个自然选择是误分类点的总数。但是，这样的损失函数不是参数w,b的连续可导函数，不易优化。损失函数的另一个选择是误分类点到超平面的总距离，感知机所采用的就是这个损失函数。为此，首先写出输入空间 中任一点 Xo 到超平面距离:

||w|| 是 w的L2范数

对于误分类数据（xi,yi）:
$$-yi(w•xi+b)>0$$
误分类点xi到S的距离：

• 1 / ||w|| * yi*(w•xi + b)

误分类点特征：
$$w•xi+b>0,yi=-1$$
$$w•xi+b<0,yi=+1$$

设S的误分类点集合为M，则误分类点到S的总距离：
$$-1/||w||\sum yi(w•xi+b)(xi∊M)$$
判断误分类点
$$真实值\ast 预测值=+1正确分类；$$

$$真实值\ast 预测值=-1误分类；$$

不考虑 1 / ||w|| --> 损失函数 :
$$L(w,b)=-\sum yi(w•xi+b)(xi∊M)$$

• 选取损失函数最小的模型参数w,b

感知机学习算法：随机梯度下降法，任选一个超平面w0,b0,然后梯度下降法不断地极小化目标函数。极小化过程不是一次使M中所有误分类点的梯度下降，而是一次随机选取一个误分类点使其梯度下降；

损失函数L(w,b)的梯度由：
$$\nabla wL(w,b)=-\sum yixi(xi∊M)$$

$$\nabla bL(w,b)=-\sum yi(yi∊M)$$

随机选取误分类点(xi,yi),对w,b进行更新

w ⬅ w+ɧyixi
b ⬅ b+ɧyi

例题：

解：构建最优化问题
$$minL(w,b)=-\sum yi(w•xi+b)(xi∊M)$$

代码示例：

import numpy as np
import matplotlib.pyplot as plt

p_x = np.array([[3, 3], [4, 3], [1, 1]])  # 创建数据集     x值
y = np.array([1, 1, -1])  # 标记数据集     1：正类；-1：负类    y值
plt.figure()  # 创建图像

for i in range(len(p_x)):  # 遍历数据集  在图中标记数据集各点
    if y[i] == 1:
        plt.plot(p_x[i][0], p_x[i][1], 'ro')  # 将数据集中正类点标记为红色实心点
    else:
        plt.plot(p_x[i][0], p_x[i][1], 'bo')  # 负类标记为蓝色实心点

w = np.array([1, 0])  # 初始化权重系数w
b = 0  # 初始化偏移常数b
delta = 1  # 步长 1

for i in range(100):
    choice = -1  # 初始化标记参数choice
    for j in range(len(p_x)):
        if y[j] != np.sign(np.dot(w, p_x[0]) + b):  # w与p_x内积 + b > 0 则sign=1;< 0 则sign=-1   （sign == y[i] 正确分类）
            choice = j
            break
    if choice == -1:
        break
    w = w + delta * y[choice] * p_x[choice]  # 更新参数
    b = b + delta * y[choice]

line_x = [0, 10]  # 绘制x坐标系
line_y = [0, 0]

for i in range(len(line_x)):
    line_y[i] = (-w[0] * line_x[i] - b) / w[1]      # 绘制超平面

plt.plot(line_x, line_y)
plt.savefig("picture.png")

实现结果：

感知机模型的对偶形式

1. 感知机（Perceptron）概述

1957年被提出，是一种有单层计算单元的神经网络模型，在结构上与M-P模型相似，提出初衷是解决数据的分类问题。感知机是神经网络和支持向量机的基础。

2. 感知机原理

感知机本身是一种能进行二分类的线性模型。只要被处理的数据线性可分，就能使用感知机模型训练得到二分类模型。若数据线性不可分，训练会出现模型来回震荡的情况。
单层感知机模型图

感知机的数学表达式：f(x) = sign(wx+b)
其中，x为输入向量，w为输入向量对应权重值，b为偏置，w·x是点积，sign为符号函数，其定义：
$$sign(x)=\{\begin{array}{l}+1,x>0\\ -1,x<0\end{array}$$
由此可得到
$$sign(\omega \cdot x+b)=\{\begin{array}{l}+1,\omega \cdot x+b>0\\ -1,\omega \cdot x+b<0\end{array}$$

如果输入向量x是要进行分类的数据，那么输出结果正负1就可以看作数据经过模型计算后输出的对应标签，这样我们就可以将输入x分为两类。如果处在二维平面中，$\omega \cdot x+b=0$对应的直线就是将输入数据二分类的直线，也称为分割超平面（Separating Hyperplane）。

感知机优点：很容易处理线性可分问题，缺点：不能处理异或问题，即不能处理非线性问题。因此出现可处理非线性问题的多层感知机。感知机是一个有监督的学习算法；

3. 感知机学习策略

有了模型之后就需要确定模型的参数；模型的参数就是w和b，即权重和偏置。我们希望找到一个好的w和b，来得到好的分类超平面，能够把所有的样本进行非常好的划分。

做法：实际上学习的策略就是要为感知机模型或者任意一个模型来定义一个损失函数（损失函数就是衡量一下当前模型性能对于已知的样本分类的准不准。有一个训练数据，模型在训练数据上有多少是对的，有多少是错的，那些犯错的地方就是给模型带来损失的地方），怎么衡量一个模型在数据上的损失呢？有两种选择：其一是误分类点的数目。其二是误分类点到超平面的总距离。

感知机的学习问题就转化为如何使的损失函数最小化。
对函数的极值进行求解的时候，最基本的算法叫做梯度下降法。所有的梯度下降法第一步都要初始化。所谓初始化就是把里边未知的参数我要给他赋一个值。对于这里随机的对w和b进行初始化实际上就是随机的选择了一个超平面。

其中$\eta$是我们对参数进行优化放缩的，下降的步长。$\eta$取的很大，那么他的下降速度就会很快

算法分解：

1、输入；（是训练集和学习率）

对于这个算法来说数据的输入首先要有一个训练的数据集，对于感知机来说他是一个监督学习算法，他是有监督的，所以他的数据都是以输入的向量和他所对应的类别标签形成的一个样本，是第一个样本，一直到是第N个样本，构成了一个包含有N个样本的训练数据集T，其中每一个输入的他都是一个n维的实数向量，是从1到N，有N个样本。他的输出空间是+1或者-1，他本质上是一个二类的分类模型。Binary class。另一个参数学习率也是我们认为指定的，就是我们以一个什么样的学习率来更新我们的参数（这个不是我们学习得来的，而是通过人工经验来设置的一个参数）。

2、输出；（使我们要学习的模型参数w和b）

实际上就是找到f(x)函数，该函数实际上就是确定w和b。有了w和b以后输入x的话我就可以给你算出相应的值来。实际上输出就是这个w和b就是这个权重向量和偏差。
3、算法流程；

（1）初始化w和b。

（2）在训练集当中逐个的选取训练数据的样本，比如说i从1到N逐个的选取。（循环遍历所有的数据样本）

（3）如果选取的样本满足$y_i(\omega x+b)<=0$，这就意味着用我当前的w和b，得出来的分类是错了，也就是说我现在这个模型对$(x_i,y_i)$分类是有误的。（整体为负说明计算的这部分结果的符号，和真实的符号是不一致的，所以小于0分类是错误的。（本来两者应该是同号的才表示分类是正确的）)如果分类是错误的，就要更新w和b。更新的方法就是现在的当前的w或者b加上他的偏导乘以学习率，这样就得到一个新的w和b，这就更新了w和b。

（4）更新完w和b之后接下来就是一个循环的过程，就转回到（2），再接着从训练集里边选取新的数据，下一个数据$(x_i,y_i)$，如果他分类错误了我继续还是更新w和b。一直到我把所有的数据都能够正确分类了，直至训练集中没有误分类点，也就是这个算法收敛了。因为模型把所有的训练集都能够正确分类了。那么模型就到此学习过程就结束了。

4. 感知机 Vs 支持向量机

前者最大程度追求正确划分，最小化错误，容易发生过拟合；后者尽量同时避免过拟合
前者的学习策略是最小化损失函数并使用梯度下降法；后者采用的是利用不等式的约束条件构造拉格朗日函数并求极值
前者无最优解，或者说解不唯一

5. 算法实现
   原文链接：https://blog.csdn.net/huanyingzhizai/article/details/93525995

import numpy as np  
import matplotlib.pyplot as plt  


class showPicture:  
    '''
    超平面可视化
    '''
    def __init__(self, x, y, w, b):  
        self.b = b  
        self.w = w  
        plt.figure()  
        plt.title('')  
        plt.xlabel('$x^{(1)}$', size=14)  
        plt.ylabel('$x^{(2)}$', size=14, rotation = 0)  
        
        # 绘制分离超平面
        xData = np.linspace(0, 5, 100)  
        yData = self.expression(xData)  
        plt.plot(xData, yData, color='r', label='y1 data')      
        
        # 绘制数据点
        nums = x.shape[0]
        for i in range(nums):
            plt.scatter(x[i][0],x[i][1], c = 'r' if y[i] == 1 else 'b', marker =  '+' if y[i] == 1 else '_', s = 150)
        
        plt.savefig('img/perceptron/incomplement01.png',dpi=75) 
        
    def expression(self,x):
        '''
        根据模型参数预测新的数据点的分类结果
        '''
        y = (-self.b - self.w[0]*x)/self.w[1]  
        return y  
    
    def show(self):  
        plt.show()
        

class perceptron: 
    '''
    感知机模型
    '''
    def __init__(self,x,y,a=1): 
        '''
        训练数据集X，Y
        学习率a设置为1  
        '''
        self.x = x  
        self.y = y  
        self.w = np.zeros((x.shape[1],1))    # 选取初值w0，b0  
        self.b = 0  
        self.a = 1  
    
    def sign(self,w,b,x):  
        '''
        定义符号函数
        '''
        y = np.dot(x,w)+b  
        return int(y)  
    
    def train(self, logprint = False):  
        '''
        训练感知机模型
        logprint：是否打印每次迭代结果，默认不打印
        '''
        flag = True  
        length = len(self.x)  
        while flag:  
            count = 0    # 迭代控制  
            for i in range(length):  
                tmpY = self.sign(self.w,self.b,self.x[i,:])  
                if tmpY*self.y[i]<=0:    # 若数据被误分类  
                    tmp = self.y[i]*self.a*self.x[i,:]  
                    tmp = tmp.reshape(self.w.shape)    # 梯度下降ayi_x_i存储为列向量  
                    self.w = tmp +self.w    # 权值更新  
                    self.b = self.b + self.y[i]    # 偏置更新  
                    count +=1  
                    if logprint == True:    # 打印日志
                        print('第%d次迭代：\n更新后参数 w 为%f，b 为%f' %(count, self.w, self.b))
            if count == 0:  
                flag = False    # 无误分退出迭代  
        return self.w,self.b

    
x = np.array([3, 3, 4, 3, 1, 1]).reshape(3, 2)
y = np.array([1, 1, -1])

testp = perceptron(x, y)
w, b = testp.train()

tests = showPicture(x, y, w, b)

参考链接：https://blog.csdn.net/m0_37957160/article/details/113922919
https://blog.csdn.net/huanyingzhizai/article/details/93525995

一.前言

神经网络算法属于机器学习领域中比较热门的内容，而谈到神经网络算法的历史，就不得不提到M-P神经元和基于其构建的感知机模型，虽然该算法有巨大的不足，但是对于我们深入理解复杂的神经网络也是很有帮助的，为此本文聚焦于感知机模型的解读及其实现，话不多说，请看下文。

二.算法详解

2.1 神经元

在正式介绍感知机前，需要先了解神经元的概念。我们知道，生物神经网络是由一个个神经元构成的，每个神经元都具有多个树突和一个轴突，其中树突用来接受信息，轴突可以通过尾端的轴突末梢（即突触）跟其他神经元的树突连接进行信号的传递。

神经元之间的信息传递属于化学物质传递。当神经元兴奋时，其会向与其相连的神经元发送化学物质，从而改变这些神经元内的电位，当其电位超过一定的阈值后，神经元便会被激活，即兴奋起来，然后向其它神经元发送化学物质。

注：图1来源于神经元的维基百科。

1943年，McCulloch和Pitts参考生物的神经元结构，提出了M-P神经元模型。图2中展示的便是M-P神经元，从图中便可以看出，该模型可以接收其他神经元输入的信号，这些信号通过带权重的连接进传递，神经元接受到的总输入信号会与神经元的阈值进行比较，然后通过激活函数处理以产生神经元的输出。

注：图2来源于周志华《机器学习》的图5-1。

对于M-P神经元，其使用的激活函数为阶跃函数，其将输入映射为输出值0（神经元抑制）或1（神经元兴奋），其数学定义为：
$$\text{sgn}(x)=\{\begin{array}{l}1,x\ge 0\\ 0,x<0\end{array}\text{\hspace{1em}(1)}$$

阶跃函数的数学性质不太好，例如不连续，因此经常使用Sigmoid来进行替代。

2.2 感知机

感知机（Perceptron）模型包含两层神经元，即输入层和输出层（示例参见图3），其中输入层接受外界信号后传递给输出层，输出层为M-P神经元。

感知机模型的数学形式为：
$$y=f(\sum _i{w}_i{x}_i-\theta )\text{\hspace{1em}(2)}$$
其中$f$表示阶跃函数，$x_i$和$w_i$分别表示第$i$个输入及其对应的输入权重，$\theta$表示阈值。感知机模型中的权重参数$w_i$和阈值参数$\theta$都可以通过学习得到，其中阈值$\theta$可以看作一个固定输入为$-1.0$的哑结点所对应的连接权重。

感知机的学习规则为：对训练样例$(\mathbf{x},y)$，若当前感知机的输出为$\hat{y}$，则感知机将这样调整权重：
$$\begin{gathered} w_i\leftarrow w_i+\Delta w_i \\ \Delta w_i=\eta (y-\hat{y})x_i\text{\hspace{1em}(3)} \end{gathered}$$
其中$\eta \in (0,1)$被称之为学习率，从上述公式可知，当模型的预测正确时，$\Delta w_i=0$，此时感知机将不发生变化，否则将根据错误的程度进行权重调整。

感知机只能处理线性可分的问题，这是其致命的缺陷，当年也正是关于这个缺陷的证明，使得深度学习进入第一个”寒冬“。

三.具体实现

3.1 数据集构造

为了可视化方便，本算法拟构造二维数据集，数据集中的样本分为两类，一类的标签为$1$，另一类的标签为$0$，下面是构造数据集的源码：

def generateDataset(num_samples, loc = 4, scale = 2, num_features = 2):
    """
    生成二分类数据集
    num_samples: 样本数
    num_features: 样本的特征数
    """
    size = num_samples // 2
    # 生成样本
    x1 = np.random.normal(loc, scale, (size, num_features))
    x2 = np.random.normal(-loc, scale, (num_samples - size, num_features))
    x = np.vstack((x1, x2))
    # 生成标签
    y = np.zeros(num_samples)
    y[:size] = 1
    # 打乱数据集
    indices = np.arange(num_samples)
    np.random.shuffle(indices)
    x = x[indices]
    y = y[indices]

    return x,y

构造好数据集后，还对数据集进行了打乱操作。

3.2 模型实现、训练及结果

根据第二节中的描述，我们很容易就可以实现一个感知机模型：

class Perceptron():
    def __init__(self,in_feats) -> None:
        # + 1 means \theta
        self.w = np.random.randn(1, in_feats + 1) * 0.01
    
    def sgn(self,x):
        """
        阶跃函数
        """
        return int(x >= 0)


    def forward(self,x):
        """
        x: 样本 (num_features, 1)
        """
        y_hat = np.dot(self.w,x)
        return self.sgn(y_hat)
    
    def update(self,y_hat,y,lr,x):
        """
        权重调整
        y_hat: 预测值
        y: 真实标签
        lr: 学习率
        x: 样本 (num_features, 1)
        """
        self.w += lr * (y - y_hat) * x.T

在实现的感知机模型中需要传入样本的特征数，在实验过程中，先调用数据集构造函数先生成一个包含1000个样本的二维点集，某次实验中生成的数据集可视化如下图4所示。

然后需要创建Perceptron类的实例并进行模型的训练，实现的完整源码如下所示：

from data import generateDataset
import matplotlib.pyplot as plt
from model import Perceptron
import numpy as np

def train(model,x,y,lr,accuracy=None):
    flag = True
    epoch = 0
    while flag:
        epoch += 1
        count = 0
        for i in range(x.shape[0]):
            y_hat = model.forward(x[i, :].reshape(-1, 1))
            if y[i] != y_hat:
                model.update(y_hat, y[i], lr, x[i, :].reshape(-1, 1))
                count += 1
        acc = 1 - count / x.shape[0]
        print("Epoch {}: Accuracy: {:.4f}".format(epoch, acc))
        # 完全分类正确或分类的准确率达到设定的标准
        if not count or ( accuracy and acc >= accuracy):
            flag = False
    
if __name__ == "__main__":
    loc = 5
    scale = 2
    num_samples = 1000
    num_features = 2
    lr = 0.01
    x,y = generateDataset(num_samples, loc, scale, num_features)
    # 生成数据的可视化
    plt.figure()
    plt.scatter(x[:,0],x[:,1],c=y)
    plt.savefig("org_dataset.png")
    plt.show()
    # 添加阈值对应的固定输入列
    neg_ones = -np.ones((num_samples, 1))
    x = np.hstack((x,neg_ones))
    # 初始化模型
    model = Perceptron(in_feats=num_features)
    # 训练
    train(model, x, y, lr)
    w1,w2,theta = model.w.flatten()
    x1 = np.linspace(-10, 10, 1000)
    y1 = (-w1 * x1 + theta) / w2
    plt.figure()
    plt.scatter(x[:,0],x[:,1],c=y)
    plt.plot(x1,y1,c='r')
    plt.savefig("outcome.png")
    plt.show()

训练后的结果展示如下：

结论：可见，经过训练感知机模型能够成功学得一个将线性可分的数据集划分的超平面。但在实际中，完全线性可分是很难做到的，因此可以在训练过程中设置一个结果指标，当训练的结果达到该指标即可，而不必过于苛求完美（源码也由对应的实现）。

四.结语

参考文献：《机器学习》——周志华

以上便是本文的全部内容，要是觉得不错的话，可以点个赞或关注一下博主，后续还会持续带来各种干货，当然要是有问题的话也请批评指正！！！