感知机Python代码实现（Python3.9）：

import pandas as pd  #数据分析库
import numpy as np #数值计算扩展，用来存储和处理大型矩阵
import matplotlib.pyplot as plt #导入画图工具包
from sklearn.datasets import load_iris 
#从机器学习包中导入load_iris数据集
#ris数据集的中文名是安德森鸢尾花卉数据集，英文全称是Anderson’s Iris data set
#iris包含150个样本，对应数据集的每行数据
#每行数据包含每个样本的四个特征(花萼长度、花萼宽度、花瓣长度、花瓣宽度)和样本的类别信息(targe)
#iris数据集是一个150行5列的二维表
#iris数据集及简介链接:https://blog.csdn.net/java1573/article/details/78865495
iris=load_iris() #导入数据
df = pd.DataFrame(iris.data, columns=iris.feature_names)
#将iris中的四个特征数据放入df矩阵中
#DataFrame介绍：https://www.jianshu.com/p/8024ceef4fe2
df['label']=iris.target
#在df矩阵的最后插入一列label即样本类别
df.columns=['sepal length','sepal width','petal length','petal width','label']
#输入print(df)即可查看
plt.figure(figsize=(15, 8))
#figsize:指定figure的宽和高
#plt.figure()的使用:https://blog.csdn.net/m0_37362454/article/details/81511427
plt.subplot(131)
#subplot绘制多个子图介绍:https://www.cnblogs.com/xiaoboge/p/9683056.html
plt.scatter(df[:50]['sepal length'], df[:50]['sepal width'], label='0')
#画散点图
plt.scatter(df[50:100]['sepal length'], df[50:100]['sepal width'], label='1')
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.title('original data')
plt.legend()

data = np.array(df.iloc[:100, [0, 1, -1]])
#读取df的前100行，第一、二、五列（'sepal length','sepal width','label')
#array：计算机为数组分配一段连续的内存，从而支持对数组随机访问
#要选取连续多列就该使用df.iloc
#iloc的用法示例：https://blog.csdn.net/qq_39697564/article/details/87855167
X, y = data[:,:-1], data[:,-1]
#令X等于'sepal length','sepal width'的100个二维数据，令y等于100个类别（只有0,1）
y = np.array([1 if i == 1 else -1 for i in y])
#对标记数据进行标准化为1或-1，当y为1时仍为1，其他的变为-1

class Model:
    def __init__(self):
        self.w = np.ones(len(data[0]) - 1, dtype = np.float32)
        self.b = 0
        self.l_rate = 0.1
        #ones在这生成一个比data列数少1的数组，此处data[0]表示data的第1行，len表示长度
        #选取w,b和学习率l_rate的初值
        # ones介绍：https://blog.csdn.net/qq_28618765/article/details/7808545
        #_init_介绍：https://www.zhihu.com/question/46973549

    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 'Perceptron Model!'
#随机梯度下降法
# range创建一个整数列表，默认从0开始
# range() 函数用法: http://www.runoob.com/python/python-func-range.html
#python中的self介绍：https://blog.csdn.net/xrinosvip/article/details/89647884

perceptron = Model()
perceptron.fit(X, y)

x_points = np.linspace(4,7,10)
#从4到7之间创建10个等差序列，包括7
#linspace的用法:https://blog.csdn.net/weixin_40103118/article/details/78787454
y_ = -(perceptron.w[0]*x_points + perceptron.b)/perceptron.w[1]
#根据上面的结果得到了方程，画图时根据w1x1+w2x2+b=0进行画图
#由于画图时是二维的，这里的横轴x表示x1即第一个特征，纵轴y表示x2即第二个特征
plt.subplot(132)
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.title('perceptron byhand')
plt.legend()

from sklearn.linear_model import Perceptron
clf = Perceptron(fit_intercept=True, max_iter=1000, shuffle=True)
#fit_intercept表示是否保留截距
clf.fit(X, y)

print(clf.coef_)
#输出系数w
print(clf.intercept_)
#输出截距b
x_ponits = np.arange(4, 8)
y_ = -(clf.coef_[0][0]*x_ponits + clf.intercept_)/clf.coef_[0][1]
#根据上面的结果得到了方程，画图时根据w1x1+w2x2+b=0进行画图
#由于画图时是二维的，这里的横轴x表示x1即第一个特征，纵轴y表示x2即第二个特征
plt.subplot(133)
plt.plot(x_ponits, 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.title('perceptron by sklearn')
plt.legend()

plt.subplots_adjust(top=0.92, bottom=0.08, left=0.10, right=0.95, hspace=0.25,wspace=0.35)
#调整子图间距
plt.savefig("demo.jpg")
plt.show()

第一次使用Python敲代码，加了很多注释，代码参考的第2章 感知机(Perceptron)代码实现

后半部分Perceptron使用没理解，持续更新中…

回顾

感知机

前面我们介绍了感知机，它是一个二分类的线性分类器，输入为特征向量，输出为实例的类别。感知机算法利用随机梯度下降法对基于误分类的损失函数进行最优化求解，得到感知机模型，即求解$w,b$。感知机算法简单易于实现，那么我们如何通过python代码来实现呢？

接下来我们通过对我们给定的数据进行训练，得到最终的$w,b$，并将其可视化。

Python实现

import copy
from matplotlib import pyplot as plt
from matplotlib import animation

training_set = [[(1, 2), 1], [(2, 3), 1], [(3, 1), -1], [(4, 2), -1]]  # 训练数据集
w = [0, 0]  # 参数初始化
b = 0
history = []  # 用来记录每次更新过后的w,b


def update(item):
    """
    随机梯度下降更新参数
    :param item: 参数是分类错误的点
    :return: nothing 无返回值
    """
    global w, b, history  # 把w, b, history声明为全局变量
    w[0] += 1 * item[1] * item[0][0]  # 根据误分类点更新参数,这里学习效率设为1
    w[1] += 1 * item[1] * item[0][1]
    b += 1 * item[1]
    history.append([copy.copy(w), b])  # 将每次更新过后的w,b记录在history数组中


def cal(item):
    """
    计算item到超平面的距离,输出yi(w*xi+b)
    （我们要根据这个结果来判断一个点是否被分类错了。如果yi(w*xi+b)>0,则分类错了）
    :param item:
    :return:
    """
    res = 0
    for i in range(len(item[0])):  # 迭代item的每个坐标，对于本文数据则有两个坐标x1和x2
        res += item[0][i] * w[i]
    res += b
    res *= item[1]  # 这里是乘以公式中的yi
    return res


def check():
    """
    检查超平面是否已将样本正确分类
    :return: true如果已正确分类则返回True
    """
    flag = False
    for item in training_set:
        if cal(item) <= 0:  # 如果有分类错误的
            flag = True  # 将flag设为True
            update(item)  # 用误分类点更新参数
    if not flag:  # 如果没有分类错误的点了
        print("最终结果: w: " + str(w) + "b: " + str(b))  # 输出达到正确结果时参数的值
    return flag  # 如果已正确分类则返回True,否则返回False


if __name__ == "__main__":
    for i in range(1000):  # 迭代1000遍
        if not check(): break  # 如果已正确分类，则结束迭代
    # 以下代码是将迭代过程可视化
    # 首先建立我们想要做成动画的图像figure, 坐标轴axis,和plot element
    fig = plt.figure()
    ax = plt.axes(xlim=(0, 2), ylim=(-2, 2))
    line, = ax.plot([], [], 'g', lw=2)  # 画一条线
    label = ax.text([], [], '')


    def init():
        line.set_data([], [])
        x, y, x_, y_ = [], [], [], []
        for p in training_set:
            if p[1] > 0:
                x.append(p[0][0])  # 存放yi=1的点的x1坐标
                y.append(p[0][1])  # 存放yi=1的点的x2坐标
            else:
                x_.append(p[0][0])  # 存放yi=-1的点的x1坐标
                y_.append(p[0][1])  # 存放yi=-1的点的x2坐标
        plt.plot(x, y, 'bo', x_, y_, 'rx')  # 在图里yi=1的点用点表示，yi=-1的点用叉表示
        plt.axis([-6, 6, -6, 6])  # 横纵坐标上下限
        plt.grid(True)  # 显示网格
        plt.xlabel('x1')  # 这里我修改了原文表示
        plt.ylabel('x2')  # 为了和原理中表达方式一致，横纵坐标应该是x1,x2
        plt.title('Perceptron Algorithm (www.hankcs.com)')  # 给图一个标题：感知机算法
        return line, label

    def animate(i):
        global history, ax, line, label
        w = history[i][0]
        b = history[i][1]
        if w[1] == 0: return line, label
        # 因为图中坐标上下限为-6~6，所以我们在横坐标为-7和7的两个点之间画一条线就够了，这里代码中的xi,yi其实是原理中的x1,x2
        x1 = -7
        y1 = -(b + w[0] * x1) / w[1]
        x2 = 7
        y2 = -(b + w[0] * x2) / w[1]
        line.set_data([x1, x2], [y1, y2])  # 设置线的两个点
        x1 = 0
        y1 = -(b + w[0] * x1) / w[1]
        label.set_text(history[i])
        label.set_position([x1, y1])
        return line, label


    print("参数w,b更新过程：", history)
    anim = animation.FuncAnimation(fig, animate, init_func=init, frames=len(history), interval=1000, repeat=True,
                                   blit=True)
    plt.show()

运行结果

最终结果: w: [-3, 4]b: 1
参数w,b更新过程： [[[1, 2], 1], [[-2, 1], 0], [[-1, 3], 1], [[-4, 2], 0], [[-3, 4], 1]]

感知机模型

感知机模型的对偶形式
感知机是一种判别模型，使用于二分类问题，输入为实例的特征向量，输出实例的类别；取-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")

实现结果：

感知机模型的对偶形式