用Python从零构建感知器：AND/OR逻辑门的实战演练
第一次接触神经网络时，很多人会被复杂的数学公式吓退。但事实上，神经网络的基础单元——感知器（Perceptron）——其核心思想简单得令人惊讶。本文将带你用不到100行Python代码，亲手实现一个能够学习AND和OR逻辑门的感知器模型。我们不会涉及任何高深的数学推导，而是通过直观的代码示例和实时权重可视化，让你在Jupyter Notebook或PyCharm中直接感受机器学习的"学习"过程。
1. 感知器基础：神经网络的乐高积木
想象一下，你正在教一个三岁小孩区分苹果和橙子。你会指着颜色说："红色的是苹果，橙色的是橙子。"感知器的工作原理与此惊人地相似——它通过调整内部的"权重"（weights）和"偏置"（bias）来学习区分不同的输入模式。
感知器的核心是一个简单的数学函数：
def predict(inputs): weighted_sum = sum(w*x for w,x in zip(weights, inputs)) + bias return 1 if weighted_sum > 0 else 0 # 阶跃函数这个函数做了三件事：
- 计算输入信号与权重的点积（加权和）
- 加上偏置项（可以理解为难易程度的调节）
- 通过激活函数（这里用阶跃函数）产生输出
对于AND逻辑门，我们希望感知器学会以下规则：
| x1 | x2 | 输出 |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
2. 构建感知器类：面向对象实现
让我们用Python类来封装感知器的核心功能。这个实现特别注重可解释性——我们会在训练过程中打印权重变化，让你直观看到学习是如何发生的。
class Perceptron: def __init__(self, input_size): self.weights = [0.0] * input_size # 初始化权重为零 self.bias = 0.0 # 初始化偏置为零 def predict(self, inputs): """预测函数：计算加权和并应用阶跃函数""" total = sum(w * x for w, x in zip(self.weights, inputs)) + self.bias return 1 if total > 0 else 0 def train(self, training_data, labels, epochs=20, learning_rate=0.1): """训练函数：通过数据迭代调整权重""" for epoch in range(epochs): print(f"Epoch {epoch+1}: weights={self.weights}, bias={self.bias}") for inputs, label in zip(training_data, labels): prediction = self.predict(inputs) error = label - prediction # 更新权重 self.weights = [w + learning_rate * error * x for w, x in zip(self.weights, inputs)] self.bias += learning_rate * error关键点：学习率(learning_rate)控制着每次权重调整的幅度。太小会导致学习过慢，太大可能无法收敛。
3. 训练AND逻辑门：分步演示
现在让我们用这个类来训练一个AND逻辑门。我们将逐步展示训练过程中权重的变化，让你看到模型是如何"学会"这个简单模式的。
# AND逻辑门训练数据 and_inputs = [[0, 0], [0, 1], [1, 0], [1, 1]] and_labels = [0, 0, 0, 1] # 创建感知器实例 and_perceptron = Perceptron(input_size=2) # 开始训练 and_perceptron.train(and_inputs, and_labels) # 测试训练结果 print("\n测试AND逻辑门:") for inputs in and_inputs: print(f"{inputs} -> {and_perceptron.predict(inputs)}")典型的训练过程输出可能如下（具体数值可能因初始条件和学习率而略有不同）：
Epoch 1: weights=[0.0, 0.0], bias=0.0 Epoch 2: weights=[0.1, 0.1], bias=-0.1 Epoch 3: weights=[0.2, 0.1], bias=-0.1 ... Epoch 10: weights=[0.3, 0.3], bias=-0.4观察最终权重，你会发现它们满足不等式：w1x1 + w2x2 + b > 0 只有当x1和x2都为1时才成立。这就是AND逻辑的数学表达！
4. 实现OR逻辑门：微小调整带来的巨大变化
OR逻辑门与AND的唯一区别在于标签数据。这展示了感知器框架的灵活性——同样的代码，只需改变训练数据，就能学习完全不同的逻辑。
# OR逻辑门训练数据 or_inputs = [[0, 0], [0, 1], [1, 0], [1, 1]] or_labels = [0, 1, 1, 1] # 创建新的感知器实例 or_perceptron = Perceptron(input_size=2) # 开始训练 or_perceptron.train(or_inputs, or_labels) # 测试训练结果 print("\n测试OR逻辑门:") for inputs in or_inputs: print(f"{inputs} -> {or_perceptron.predict(inputs)}")OR感知器的权重通常会收敛到较小的正值，而偏置为一个较小的负值。这使得只要任一输入为1，加权和就能超过阈值。
5. 可视化决策边界：理解感知器的局限性
为了更深入理解感知器的工作原理，我们可以绘制它的决策边界。这能直观展示感知器是如何在输入空间中划分不同类别的。
import matplotlib.pyplot as plt import numpy as np def plot_decision_boundary(perceptron, title): # 创建网格点 x_min, x_max = -0.5, 1.5 y_min, y_max = -0.5, 1.5 xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.01), np.arange(y_min, y_max, 0.01)) # 预测每个网格点的类别 Z = np.array([perceptron.predict([x, y]) for x, y in zip(xx.ravel(), yy.ravel())]) Z = Z.reshape(xx.shape) # 绘制决策边界和训练点 plt.figure(figsize=(8, 6)) plt.contourf(xx, yy, Z, alpha=0.4) plt.scatter([0, 0, 1, 1], [0, 1, 0, 1], c=and_labels if title=="AND" else or_labels, s=100, edgecolors='k') plt.title(f"感知器决策边界 ({title})") plt.xlabel("x1") plt.ylabel("x2") plt.show() # 绘制AND和OR的决策边界 plot_decision_boundary(and_perceptron, "AND") plot_decision_boundary(or_perceptron, "OR")从图中你可以清晰地看到一条直线完美地将不同类别的点分开。这也揭示了感知器的一个重要特性：它只能解决线性可分的问题。对于更复杂的模式（如XOR），单层感知器就无能为力了——这正是多层神经网络（深度学习）出现的原因。
6. 超参数实验：学习率和训练轮次的影响
感知器的表现很大程度上取决于两个关键超参数：学习率(learning_rate)和训练轮次(epochs)。让我们通过实验看看它们如何影响训练过程。
def train_with_params(learning_rate, epochs): p = Perceptron(2) p.train(and_inputs, and_labels, epochs=epochs, learning_rate=learning_rate) accuracy = sum(1 for inputs, label in zip(and_inputs, and_labels) if p.predict(inputs) == label) / len(and_labels) print(f"学习率={learning_rate}, 轮次={epochs} -> 准确率={accuracy*100}%") # 不同参数组合实验 params = [ (0.01, 10), (0.01, 100), # 小学习率 (0.1, 10), (0.1, 100), # 中等学习率 (1.0, 10), (1.0, 100) # 大学习率 ] for lr, ep in params: train_with_params(lr, ep)实验结果可能显示：
- 学习率太小（0.01）时，模型需要更多轮次才能收敛
- 学习率适中（0.1）时，模型能在较少的轮次内达到高准确率
- 学习率太大（1.0）时，模型可能震荡甚至无法收敛
7. 从感知器到现代神经网络
虽然我们的感知器很简单，但它包含了现代神经网络的所有核心概念。多层感知器(MLP)本质上就是多个感知器的堆叠，通过非线性激活函数（如ReLU）连接起来。深度学习中的反向传播算法也是感知器学习规则的扩展。
# 一个简单的多层感知器伪代码示例 class MLP: def __init__(self, layer_sizes): self.layers = [] for i in range(len(layer_sizes)-1): # 每层都是一个感知器集合 layer = [Perceptron(layer_sizes[i]) for _ in range(layer_sizes[i+1])] self.layers.append(layer) def predict(self, inputs): for layer in self.layers: inputs = [neuron.predict(inputs) for neuron in layer] return inputs理解了这个简单的感知器实现，你就掌握了神经网络最基础也最重要的构建块。下次当你使用复杂的深度学习框架时，记住：在核心处，它们仍然在做着类似的事情——调整权重以最小化误差。
