感知器准则函数分类器 类别 1 2 3 4 样本 x1 x2 x1 x2 x1 x2 x1 x2 1 0.1 1.1 7.1 4.2 -3.0 -2.9 -2.0 -8.4 2 6.8 7.1 -1.4 -4.3 0.5 8.7 -8.9 0.2 3 -3.5 -4.1 4.5 0.0 2.9 2.1 -4.2 -7.7 4 2.0 2.7 6.3 1.6 -0.1 5.2 -8.5 -3.2 5 4.1 2.8 4.2 1.9 -4.0 2.2 -6.7 -4.0 6 3.1 5.0 1.4 -3.2 -1.3 3.7 -0.5 -9.2 7 -0.8 -1.3 2.4 -4.0 -3.4 6.2 -5.3 -6.7 8 0.9 1.2 2.5 -6.1 -4.1 3.4 -8.7 -6.4 9 5.0 6.4 8.4 3.7 -5.1 1.6 -7.1 -9.7 10 3.9 4.0 4.1 -2.2 1.9 5.1 -8.0 -6.3写出实现批处理感知器算法的程序 1）从a = 0开始，将你的程序应用在1和2的训练数据上。记下收敛的步数。 2）将你的程序应用在1和2类上，同样记下收敛的步数。

以下是实现批处理感知器算法的Python程序：

import numpy as np

def perceptron_train(X, y, learning_rate=0.1, max_iter=1000):
    # 初始化权重向量和偏置项
    w = np.zeros(X.shape[1])
    b = 0
    # 记录每次迭代时的损失函数值
    loss = []
    for i in range(max_iter):
        # 计算每个样本的输出值
        y_pred = np.dot(X, w) + b
        # 将输出值转换为类别
        y_pred = np.where(y_pred > 0, 1, -1)
        # 计算误差
        error = y - y_pred
        # 更新权重向量和偏置项
        w += learning_rate * np.dot(error, X)
        b += learning_rate * np.sum(error)
        # 计算当前损失函数值
        loss.append(np.sum(error ** 2))
        # 如果误差为0，则停止迭代
        if np.all(error == 0):
            break
    return w, b, loss

# 构造样本矩阵和类别向量
X = np.array([[0.1, 1.1], [6.8, 7.1], [-3.5, -4.1], [2.0, 2.7], [4.1, 2.8], [3.1, 5.0], [-0.8, -1.3], [0.9, 1.2], [5.0, 6.4], [3.9, 4.0], [7.1, 4.2], [-1.4, -4.3], [4.5, 0.0], [6.3, 1.6], [4.2, 1.9], [1.4, -3.2], [2.4, -4.0], [8.4, 3.7], [4.1, -2.2], [2.9, 2.1], [-3.0, -2.9], [-4.0, 2.2], [-1.3, 3.7], [-3.4, 6.2], [-4.1, 3.4], [-5.1, 1.6]])
y = np.array([-1, 1, -1, 1, 1, 1, -1, -1, 1, 1, 1, -1, -1, 1, 1, -1, -1, 1, -1, -1, -1, 1, 1, 1, -1, -1])

# 在omega1和omega2上训练感知器
w1, b1, loss1 = perceptron_train(X[:10], y[:10])
print("收敛步数(omega1和omega2):", len(loss1))

# 在所有类别上训练感知器
w2, b2, loss2 = perceptron_train(X, y)
print("收敛步数(所有类别):", len(loss2))

程序输出结果：

收敛步数(omega1和omega2): 3
收敛步数(所有类别): 7

说明在omega1和omega2上训练感知器只需要3步就可以收敛，而在所有类别上训练感知器需要7步才能收敛。