从1957年感知机到现代神经网络：初代AI模型的原理与实现解析

1次阅读

共计 2557 个字符，预计需要花费 7 分钟才能阅读完成。

1957 年，心理学家弗兰克·罗森布拉特发明的感知机（Perceptron）是人工智能发展史上第一个可学习的神经网络模型。它的出现标志着机器学习从理论走向实践，为后来的深度学习奠定了基础。感知机最初被设计用于二分类问题，能够自动调整权重来完成简单的模式识别任务，比如区分两类不同的手写字母。

虽然感知机结构简单，但它的学习算法——通过错误驱动调整权重——成为了后续神经网络训练的核心思想。罗森布拉特在 Cornell 航空实验室的工作展示了机器如何通过经验改进性能，这一理念至今仍是 AI 领域的基石。

感知机的决策过程可以用数学公式清晰表达。给定输入向量 $\mathbf{x} = (x_1, x_2, …, x_n)$ 和对应的权重向量 $\mathbf{w} = (w_1, w_2, …, w_n)$，感知机的输出计算如下：

$$
z = \mathbf{w} \cdot \mathbf{x} + b
$$
$$
y =
\begin{cases}
1 & \text{if} z \geq 0 \
0 & \text{if} z < 0
\end{cases}
$$

其中 $b$ 是偏置项，$y$ 是最终输出。权重更新规则采用简单的误差驱动方式：

$$
\mathbf{w} = \mathbf{w} + \eta (y_{true} – y_{pred}) \mathbf{x}
$$
$$
b = b + \eta (y_{true} – y_{pred})
$$

$\eta$ 是学习率，控制每次更新的步长。这个规则表明：只有当预测错误时，才会按照输入向量的方向（或反方向）调整权重。

下面我们用 Python 和 NumPy 来实现原始感知机算法。代码包含完整的训练循环和可视化功能：

import numpy as np
import matplotlib.pyplot as plt

class Perceptron:
    def __init__(self, input_size, lr=0.01):
        self.weights = np.zeros(input_size)
        self.bias = 0
        self.lr = lr

    def predict(self, x):
        z = np.dot(x, self.weights) + self.bias
        return 1 if z >= 0 else 0

    def train(self, X, y, epochs=100):
        errors = []
        for _ in range(epochs):
            error = 0
            for xi, target in zip(X, y):
                prediction = self.predict(xi)
                update = self.lr * (target - prediction)
                self.weights += update * xi
                self.bias += update
                error += int(update != 0.0)
            errors.append(error)
        return errors

    def plot_decision_boundary(self, X, y):
        x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
        y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
        xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.01),
                             np.arange(y_min, y_max, 0.01))
        Z = np.array([self.predict(np.array([x, y])) 
                      for x, y in zip(xx.ravel(), yy.ravel())])
        Z = Z.reshape(xx.shape)
        plt.contourf(xx, yy, Z, alpha=0.4)
        plt.scatter(X[:, 0], X[:, 1], c=y, s=20, edgecolor='k')
        plt.title('Perceptron Decision Boundary')
        plt.xlabel('Feature 1')
        plt.ylabel('Feature 2')
        plt.show()

# 示例数据：线性可分的二维点
X = np.array([[2, 3], [1, 4], [3, 5], [4, 2], [2, 5], [3, 3]])
y = np.array([1, 1, 1, 0, 0, 0])

# 训练感知机
p = Perceptron(input_size=2)
errors = p.train(X, y, epochs=20)
p.plot_decision_boundary(X, y)

# 绘制训练误差
plt.plot(range(1, len(errors)+1), errors, marker='o')
plt.xlabel('Epochs')
plt.ylabel('Number of errors')
plt.title('Training Error over Epochs')
plt.show()

感知机最大的局限性是它只能解决线性可分问题。最著名的例子是 XOR（异或）问题：