机器学习笔记12——感知机模型原理以及python实现案例_机器学习感知机模型数据集实例-CSDN博客

本文链接：https://blog.csdn.net/weixin_45666566/article/details/107310692

感知机Perceptron

1、概述
2、感知机模型
- 2.1 定义
- 2.2 损失函数
3、感知机算法
- 3.1 原始形式
- 3.2 对偶形式
4、感知机与其他算法

分类和回归是机器学习的两大部分；接下来回顾一下分类模型。
对于不同的数据集，可选择的分类模型也是不同的。

【数据集的线性可分性】
给定一个数据集 $T$ ={ ${(x_1,y_1),(x_2,y_2),...,(x_N,y_N)}$ }，其中， $x_i \in R^n$ , $y_i\in$ {+1,-1},i=1,2,…,N,如果存在某个超平面S
$w x + b = 0$ 能够将数据集的正实例点和负实例点完全正确地划分到超平面的两侧,即对所有 $y_i=+1$ 的实例i，有 $wx_i+b>0$ ，对所有 $y_i=-1$ 的实例i，有 $wx_i+b<0$ ,则称数据集T为线性可分数据集，否则，称数据集T线性不可分。

1、概述

感知机是由美国学者FrankRosenblatt 在1957 年提出来的，被看作为神经网络（深度学习）的起源的算法，同时也是支持向量机的基础。

严格讲，应该称为“人工神经元”或“朴素感知机”，但是因为很多基本的处理都是共通的，所以这里就简单地称为“感知机”。

感知机是二分类的线性模型，其输入是实例的特征向量，输出的是事例的类别，分别是+1和-1，属于判别模型。

感知机要求数据集本身线性可分：感知机学习的目标是求得一个能够将训练数据集正实例点和负实例点完全正确分开的分离超平面。
在二维平面上，线性可分意味着能用一条直线将正、负样本分开；
在三维空间中，线性可分意味着能用一个平面将正、负样本分开；
在n维空间中，线性可分意味着能用n-1维超平面将正、负样本分开。
在这里插入图片描述

2、感知机模型

2.1 定义

设输入空间（特征空间）为 $X\subseteq\R^n$ ;输出空间为Y={−1,+1}
输入 $x\in X$ 为实例的特征向量输出 $y\in Y$ 为实例的类别
由输入空间到输出空间的如下函数称为感知机
$\begin{cases} 1& \text{wx+b $\geq$ 0}\\ -1& \text{wx+b<0} \end{cases}$

其中w和b为模型参数， $w\in\R^n$ 称为权值， $b\in\R$ 称为偏置。sign是符号函数。

感知机模型有直观的几何解释：线性方程wx+b=0 对应于分离超平面S,其中w为超平面S的法向量，b为S的截距。求解感知机，就是要解出w和b,得到能正确分离所有正负样本的超平面S。

在这里插入图片描述

2.2 损失函数

为找出正确的分离超平面、确定感知机模型参数，需要确定一个学习策略。在监督学习中，使用某种策略即是选用相应的损失函数。

损失函数的一个自然选择是误分类点的总数。但是，这样的损失函数不是参数 $w, b$ 的连续可导函数，不易优化。见下图，当超平面在空间中由S1连续变化至S3时，相应的法向量w也连续变化，而误分类点数量则是不连续的。

在这里插入图片描述
为此感知机采用的损失函数为:误分类点到超平面S的总距离，该函数对w和b连续可导。

损失函数：

给定训练集 $T=\{(x_1,y_1),(x_2,y_2),...,(x_N,y_N)\}$ ,其中 $x_i\in \R^n$ , $y_i\in$ Y={-1,+1},i=1,2,…,N；M为误分类点的集合。
感知机学习的损失函数为
$L(w,b)=-\sum_{x_i\in M}y_i(wx_i+b)$

易知损失函数是非负的，误分类点越少，误分类点离超平面越近，损失函数值就越小。如果没有误分类点，则损失函数值时0。感知机学习的策略是在假设空间中选取使损失函数取值最小的模型参数。

推导：

单个点 $x_i$ 到超平面S的距离为
$\frac{1}{\Vert w \Vert}\vert wx_i+b \vert$
其中， $\Vert w \Vert=\sqrt{w_1^2+w_2^2+...+w_n^2}$
$L_p$ 范数：
$\Vert w \Vert_p=(\vert w_1 \vert^p+\vert w_2 \vert^p+...+\vert w_n \vert^p)^{\frac{1}{p}}$
对于误分类点数据 $x_i,y_i)$ ,有 $y_i(wx_i+b)>0$
,因为 $y_i$ 与 $wx_i+b$ 异号.
误分类点到超平面S的距离为
$-\frac{y_i( wx_i+b)}{\Vert w \Vert}$
所有误分类点到超平面S的总距离为
$L(w,b)=-\frac{1}{\Vert w\Vert}\sum_{x_i\in M}y_i(wx_i+b)$
$\frac{1}{\Vert w\Vert}$ 为常数，不影响，去掉即为损失函数。

3、感知机算法

目标： 感知机学习算法的原始形式是求解最优化问题
${min}_{w,b}L(w,b)=-\sum_{x_i\in M}y_i(wx_i+b)$

其中M为误分类点的集合
优化方法：随机梯度下降法

3.1 原始形式

算法过程：
- 输入：线性可分的训练数据集 $T=\{(x_1,y_1),(x_2,y_2),...,(x_N,y_N)\}$ ,其中 $x_i\in X=\R^n$ , $y_i\in Y=\{-1,+1\}$ ,i=1,2,…,N ;学习率 $\eta（0\leq\eta\leq1$ ;
- 输出：参数w,b;感知机模型 $f (x) = s i g n (w x + b)$
  (1)随机选取初值 $w_0,b_0$ ,一般均选为0；
  (2)在训练集中选取数据 $x_i,y_i)$
  (3)如果 $y_i(wx_i+b)\leq0$ 即此点被误分类。
  
  $w\leftarrow w+\eta y_ix_i$ ,
  $b\leftarrow b+\eta y_i$
  
  (4)转至（2），直至训练集中没有误分类点。
每次根据 $x_i,y_i)$ 调整 $w, b$ 时，分离超平面将向该误分类点移动，以减少该误分类点与超平面的距离，越过该误分类点使其正确分类。

【代码实现】

class Perceptron_Model:
    def __init__(self):
        #len(data[0])表示数据集的列数n，特征向量个数通常为n-1，因此参数向量个数为n-1
        #初始化参数为0
        self.w = np.zeros(len(data[0]) - 1, dtype=np.float32)
        #初始化截距b为0
        self.b = 0
        #学习率
        self.l_rate = 0.1
        # self.data = data

    def sign(self, x, w, b):
        y = np.dot(x, w) + b
        return y

    # 随机梯度下降法
    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(X, self.w, self.b) <= 0:
                    self.w = self.w + self.l_rate * np.dot(y, X)
                    self.b = self.b + self.l_rate * y
                    wrong_count += 1
            if wrong_count == 0:
                is_wrong = True
        return self.w,self.b

案例：
数据集：鸢尾花数据集共有150个样本，共有三个类别，比列为1：1：1；因此我们参用前一百个数据(只有两种类别）来建立感知机模型。

import pandas as pd
import numpy as np
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt
%matplotlib inline
iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['label'] = iris.target#将目标转换为标签
df.columns = [
    'sepal length', 'sepal width', 'petal length', 'petal width', 'label'
]
#查看每个标签的数量
df.label.value_counts()
data = np.array(df.iloc[:100, [0, 1, -1]])#取前100个样本
X, y = data[:,:-1], data[:,-1]
perceptron =Perceptron_Model()
perceptron.fit(X, y)

画图：

x_points = np.linspace(4, 7, 10)
y_ = -(perceptron.w[0] * x_points + perceptron.b) / perceptron.w[1]
plt.plot(x_points, y_)

plt.plot(data[:50, 0], data[:50, 1], 'bo', color='blue', label='0')
plt.plot(data[50:100, 0], data[50:100, 1], 'bo', color='orange', label='1')
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.legend()

在这里插入图片描述
scikit-learn模块实现上述例子

import pandas as pd
import numpy as np
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt
%matplotlib inline
import sklearn
from sklearn.linear_model import Perceptron#导入感知机
#获取数据：特征向量X，目标向量y
iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['label'] = iris.target
data = np.array(df.iloc[:100, [0, 1, -1]])
X, y = data[:,:-1], data[:,-1]

clf = Perceptron(fit_intercept=True, 
                 max_iter=1000, 
                 shuffle=True)
clf.fit(X, y)
print(clf.coef_)#获取系数w
print(clf.intercept_)#截距b
#画图
# 画布大小
plt.figure(figsize=(10,10))

# 中文标题
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus'] = False
plt.title('鸢尾花线性数据示例')

plt.scatter(data[:50, 0], data[:50, 1], c='b', label='Iris-setosa',)
plt.scatter(data[50:100, 0], data[50:100, 1], c='orange', label='Iris-versicolor')

# 画感知机的线
x_ponits = np.arange(4, 8)
y_ = -(clf.coef_[0][0]*x_ponits + clf.intercept_)/clf.coef_[0][1]
plt.plot(x_ponits, y_)

# 其他部分
plt.legend()  # 显示图例
plt.grid(False)  # 不显示网格
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.legend()

3.2 对偶形式

对偶形式的基本思想是，将w和b表示为实例 $x_i$ 和标记 $y_i$ 的线性组合的形式，通过求解其系数而求得参数w和b。
在这里插入图片描述

在这里插入图片描述
简而言之，感知机的对偶形式就是把对 $w, b$ 的学习变成了对 $α, b$ 的学习，原始形式中， $w$ 在每一轮迭代错分时都需要更新，而采用对偶形式时，对于某一点 $x_i,y_i)$ 发生错分时，我们只需要更新其对应的 $α_i$ 即可。

【代码实现】

from __future__ import division
import random
import numpy as np
import matplotlib.pyplot as plt  


def sign(v):
    if v>=0:
        return 1
    else:
        return -1

def train(train_num,train_datas,lr):
    w=0.0
    b=0
    datas_len = len(train_datas)
    alpha = [0 for i in range(datas_len)]
    train_array = np.array(train_datas)
    gram = np.matmul(train_array[:,0:-1] , train_array[:,0:-1].T)
    for idx in range(train_num):
        tmp=0
        i = random.randint(0,datas_len-1)
        yi=train_array[i,-1]
        for j in range(datas_len):
            tmp+=alpha[j]*train_array[j,-1]*gram[i,j]
        tmp+=b
        if(yi*tmp<=0):
            alpha[i]=alpha[i]+lr
            b=b+lr*yi
    for i in range(datas_len):
        w+=alpha[i]*train_array[i,0:-1]*train_array[i,-1]
    return w,b,alpha,gram

def plot_points(train_datas,w,b):
    plt.figure()
    x1 = np.linspace(0, 8, 100)
    x2 = (-b-w[0]*x1)/(w[1]+1e-10)#超平面$wx+b=0$
    plt.plot(x1, x2, color='r', label='y1 data')
    datas_len=len(train_datas)
    for i in range(datas_len):
        if(train_datas[i][-1]==1):
            plt.scatter(train_datas[i][0],train_datas[i][1],s=50)  
        else:
            plt.scatter(train_datas[i][0],train_datas[i][1],marker='x',s=50)  
    plt.show()

if __name__=='__main__':
    train_data1 = [[1, 3, 1], [2, 2, 1], [3, 8, 1], [2, 6, 1]]  # 正样本
    train_data2 = [[2, 1, -1], [4, 1, -1], [6, 2, -1], [7, 3, -1]]  # 负样本
    train_datas = train_data1 + train_data2  # 样本集
    w,b,alpha,gram=train(train_num=500,train_datas=train_datas,lr=0.01)
    plot_points(train_datas,w,b)