感知机学习算法

进击的阿刚#

已于 2024-02-29 18:01:53 修改

阅读量719

点赞数 21

分类专栏：统计学习方法文章标签：机器学习人工智能

于 2024-02-28 10:22:59 首次发布

本文链接：https://blog.csdn.net/qq_47190374/article/details/136337763

版权

统计学习方法专栏收录该内容

8 篇文章 0 订阅

订阅专栏

文章目录

前言
一、感知机模型
二、感知机学习算法的原始形式
三、感知机学习算法的对偶形式
四、收敛性和依赖性
五、代码实现

前言

感知机是感知机是一个二分类线性判别模型，其输入为实例的特征向量，输出为实例的类别，取+1和-1二值。感知机对应输入空间（特征空间）中将实例划分为正负两类的分离超平面，属于判别模型。

一、感知机模型

假设输入 $x\in \mathbb{R}^n$ ，输出 $y\in\{-1,+1\}$ ，感知机为如下函数：
$f(x)=sign(w^Tx+b), \\sign(z)=\left\{\begin{aligned} 1 \qquad \quad x\ge0\\ -1 \qquad\quad x<0 \end{aligned}\right.$
其中，w叫做权重，是分类超平面的法向量；b叫做偏置，是超平面的截距。
设数据集线性可分，感知机的损失函数为所有误分类点到分类超平面的函数间隔，即：
$L(w,b)=-\sum_{x_i\in M}y_i(w^Tx+b)$

二、感知机学习算法的原始形式

输入：训练数据集 $T={(x_1,y_1),(x_2,y_2),..,(x_N,y_N)}$ ，其中 $x_i\in \mathbb{R}^n$ ， $Y_i\in\{-1,1\}$ ；学习率 $\eta\in(0,1]$
输出：w,b；感知机模型 $f(x)=sign(w^Tx+b)$

随机任选一个超平面 $w_0,b_0$ ，一般都初始化为0
在训练集中选取数据 $x_i,y_i)$
如果 $y_i(w^Tx_i+b)\le 0$ ，则更新w和b：
$w=w+\eta y_ix_i \\b=b+\eta y_i$
转至第二步，直到训练集中没有误分点

三、感知机学习算法的对偶形式

对偶形式的基本想法是，将w和b表示为实例 $x_i$ 和标签 $y_i$ 的线性组合的形式，通过求解其系数而求得w和b。由感知机算法的原始形式可以得出，修改n次过后w，b关于 $x_i,y_i)$ 的增量分别是 $\alpha_iy_ix_i$ 和 $\alpha_iy_i$ ，这里 $\alpha_i=n_i\eta$ 。这样，最后学习到的w和b可以分别表示为：
$w=\sum_{i=1}^N\alpha_iy_ix_i \\b=\sum_{i=1}^N\alpha_iy_i$
具体算法为：

输入：训练数据集 $T={(x_1,y_1),(x_2,y_2),..,(x_N,y_N)}$ ，其中 $x_i\in \mathbb{R}^n$ ， $Y_i\in\{-1,1\}$ ；学习率 $\eta\in(0,1]$

输出： $\alpha$ ,b；感知机模型 $f(x)=sign(\sum_{i=1}^N\alpha_iy_ix_ix+b)$ ，其中 $\alpha=(\alpha_1,\alpha_2,...,\alpha_N)^T$

令 $\alpha=\boldsymbol 0, b=0$
在训练集中选取数据 $x_i,y_i)$
如果 $y_i(\sum_{j=1}^N\alpha_jy_jx_jx_i+b)\le 0$ ，则更新w和b：
$\alpha=\alpha+\eta \\b=b+\eta y_i$
转至第二步，知道训练集中没有误分点

四、收敛性和依赖性

收敛性：对于线性可分的T，经过有限次搜索，可将T正确分开的分离超平面，对于线性不可分的T，算法收敛。
依赖性：不同的初值选择，或者迭代过程中不同误分类点的选择顺序，可能得到不同的分离超平面。（为了得到唯一的分离超平面，需要约束条件）

五、代码实现

代码如下（示例）：

"""
感知机
"""
import numpy as np
from sklearn.datasets import load_digits

class Perceptron(object):
    def __init__(self, m):
        self.w = np.zeros(m)  # 权重
        self.b = 0  # 偏置

    def traditional_train(self, train_x, train_y, batch_size,
                          epochs, test_x=None, test_y=None, learning_rate=1):
        """
        感知机学习算法的原始形式
        """

        num = train_x.shape[0]   # 训练集大小

        for epoch in range(epochs):
            cur = 0
            while cur < num:
                if cur+batch_size < num:
                    batch_xs = train_x[cur:cur+batch_size, :]
                    batch_ys = train_y[cur:cur+batch_size]
                else:
                    batch_xs = train_x[cur:, :]
                    batch_ys = train_y[cur:]

                pred = np.dot(batch_xs, self.w) + self.b
                pred = pred.reshape((-1,))
                pred[pred >= 0] = 1
                pred[pred < 0] = -1

                err_index = pred != batch_ys

                self.w += np.mean(batch_xs[err_index] * batch_ys[err_index].reshape(-1, 1), 0) * learning_rate
                self.b += np.mean(batch_ys[err_index]) * learning_rate

                cur += batch_size

            # 每个epoch结束输出在测试集上的精度
            if test_x is not None and test_y is not None:
                accuracy = self.test(test_x, test_y)
                print('Epoch:%d, accuracy:%.4f' % (epoch + 1, accuracy))

    def test(self, test_x, test_y):
        '''
        测试函数
        :param test_x:
        :param text_y:
        :return:
        '''
        p = np.dot(test_x, self.w) + self.b
        pred_y = (p >= 0).astype(int)
        pred_y[pred_y == 0] = -1
        accuracy = (pred_y == test_y).sum() / test_x.shape[0]

        return accuracy


if __name__ == '__main__':

    digits = load_digits()
    features = digits.data
    # 0~4为类别0，5~9为类别1
    targets = (digits.target > 4).astype(int)
    targets[targets == 0] = -1

    shuffle_indices = np.random.permutation(features.shape[0])
    features = features[shuffle_indices]
    targets = targets[shuffle_indices]

    # 划分训练、测试集
    train_count = int(len(features)*0.8)
    train_x, train_y = features[:train_count], targets[:train_count]
    test_x, test_y = features[train_count:], targets[train_count:]

    percetron = Perceptron(train_x.shape[1])

    batch_size = 64
    epochs = 20

    percetron.traditional_train(train_x, train_y, batch_size, epochs, test_x, test_y)