神经元是什么

神经网络里的「神经元」（neuron），是构成整个神经网络的最小计算单元——你可以把它想成一个会做决定的小盒子：接收若干个数字输入，按各自的重要性汇总，最后给出一个数字输出。无数这样的小盒子按层连起来，就成了能识别图像、翻译语言、跟你对话的神经网络。

一句话总结：神经元 = 加权求和 + 激活函数。

用「评审团投票」来理解

想象一个评审团要对一份方案投票。每位评审给出一个分数（这就是输入 $x_1, x_2, \dots$ ），但主席对不同评审的信任程度不一样：资深的意见权重大，新人的权重小（这就是权重 $w_1, w_2, \dots$ ）。主席自己还有个默认立场——比如他天生偏保守，会先扣掉一分再开始算（这就是偏置 $b$ ）。

主席把所有人的分数加权汇总，再叠上自己的默认立场，得到一个综合分数（这就是加权和 $z$ ）。最后，他根据综合分数做决定：分数特别高就强烈通过，特别低就强烈反对，介于中间就给出温和意见（这个「做决定」的规则，就是激活函数 $f$ ）。

整个流程，就是一个神经元干的事。

拆开看：神经元的五个零件

一个标准神经元由这几个部分协作完成：

输入 $x_i$ ：神经元接收的数字信号，可以是一张图片的像素、上一层别的神经元的输出，或一个词的特征向量。
权重 $w_i$ ：每个输入配一个权重，代表这个输入的重要性——权重越大，该输入对结果影响越大。
偏置 $b$ ：一个独立的数字，相当于神经元的「默认倾向」，让神经元更容易或更难被激活。
加权和 $z$ ：把所有「输入 × 权重」相加，再加偏置，得到汇总值。
激活函数 $f$ ：把汇总值变成最终输出的规则。它决定神经元是否「被激活」，并给整个网络引入非线性——这是神经网络能学复杂规律、而不只是做简单线性累加的关键。

在 AI 体系里，神经元是深度学习的最小积木；单个神经元能做的事很有限，但成千上万个按层组织起来，就能逼近任意复杂的函数。和它强相关的概念是「激活函数」和「多层感知机」——后者就是把神经元堆成层后的产物。

核心公式

把上面五步写成数学，就是这两行：

z = w_1 x_1 + w_2 x_2 + \cdots + w_n x_n + b = \sum_{i=1}^{n} w_i x_i + b

y = f(z)

逐项解读：

$x_i$ ：第 $i$ 个输入（第 $i$ 位评审的分数）。
$w_i$ ：第 $i$ 个权重（主席给这位评审的信任度）。
$b$ ：偏置（主席的默认立场）。
$n$ ：输入的总个数，即这位委员一共收到几条输入线索。
$\sum_{i=1}^{n}$ ：求和符号，让 $i$ 从 1 取到 $n$ 把所有「权重 × 输入」累加，就是等号左边那一长串的简写。
$z$ ：加权和，所有评审意见汇总后的综合分。
$f$ ：激活函数（主席做决定的规则）。
$y$ ：神经元的最终输出。

权重和偏置，正是神经网络在「训练」时要不断调整的东西——所谓「学习」，本质上就是反复微调这堆 $w$ 和 $b$ ，让神经元的输出越来越接近正确答案。

算一个小例子

设一个神经元有 2 个输入： $x_1 = 2$ ， $x_2 = 3$ ，权重 $w_1 = 0.5$ ， $w_2 = -1$ ，偏置 $b = 1$ 。

先算加权和：

z = 0.5 \times 2 + (-1) \times 3 + 1 = 1 - 3 + 1 = -1

再用激活函数处理。换不同的 $f$ 会得到不同输出：

用 ReLU（小于 0 一律归零）： $y = \max(0, -1) = 0$ 。
用 sigmoid（压到 0~1 之间，可以理解为「通过的信心」）： $y = \dfrac{1}{1 + e^{-(-1)}} = \dfrac{1}{1 + e^{1}} \approx 0.27$ 。

（式中的 $e$ 是自然对数的底，约等于 2.718，是一个数学常数。）

可以看到，偏置和权重的不同取值，加上不同激活函数，会让同一个输入产生完全不同的输出——这正是神经元「做决定」的灵活性来源。

图 1：同一个加权和 z = −1，过 ReLU 被直接归零、过 Sigmoid 被压成 0.27——激活函数的「形状」决定了输出长什么样。

PyTorch 里长什么样

在 PyTorch 里，nn.Linear 这一行就实现了「加权求和 + 偏置」这件事：

python

import torch.nn as nn

# 输入 3 个特征，输出 1 个值——本质上就是一个单神经元
neuron = nn.Linear(in_features=3, out_features=1)
# 内部自动维护权重 w（3 个）和偏置 b（1 个）

完整的「加权求和 + 激活函数」流程如下面的小节。

图 2：神经元「学习」就是这四步的不断循环——前向传播、算误差、反向传播、更新权重，每走一圈 w 和 b 就更准一点。

完整代码

下面是一个能直接跑的单神经元示例：用假数据演示一次前向传播和一次训练步。

python

import torch
import torch.nn as nn
import torch.nn.functional as F

# 定义一个单神经元模型：Linear 负责 w·x + b，ReLU 是激活函数
class SingleNeuron(nn.Module):
    def __init__(self, in_features):
        super().__init__()
        self.linear = nn.Linear(in_features, 1)  # 加权求和 + 偏置

    def forward(self, x):
        z = self.linear(x)        # 加权和 z = Σ wᵢxᵢ + b
        y = F.relu(z)             # 激活函数 f(z)，这里用 ReLU
        return y

# 实例化：接收 3 个输入
model = SingleNeuron(in_features=3)

# 假数据：1 个样本，3 个特征
x = torch.randn(1, 3)
target = torch.tensor([[1.0]])    # 假装正确的输出是 1

# 前向传播
y = model(x)
print("输出:", y.item())

# 训练一步：算损失 → 反向传播 → 更新权重和偏置
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

loss = criterion(y, target)       # 损失：输出和目标的差距
loss.backward()                   # 反向传播，算出每个 w 和 b 该往哪调
optimizer.step()                  # 按梯度更新 w 和 b

print("训练一步后的损失:", loss.item())

跑完你会发现，loss.backward() + optimizer.step() 这两步，正是不断微调权重和偏置的过程——也就是神经元在「学习」。

小结

神经元是神经网络的最小单元，干的事就一句：把输入按权重加权求和，加偏置，再过激活函数，得到输出。单看简单得像一道中学数学题，但成千上万个叠在一起、互相连接，就构成了今天所有大模型的基础。

参考资料

Artificial neuron - Wikipedia https://en.wikipedia.org/wiki/Artificial_neuron
动手学深度学习 - 4.1 多层感知机（李沐等） https://zh.d2l.ai/chapter_multilayer-perceptrons/mlp.html
The McCulloch-Pitts Artificial Neuron - Computational Cognition Book https://com-cog-book.github.io/com-cog-book/features/mp-artificial-neuron.html

用「评审团投票」来理解 ​

拆开看：神经元的五个零件 ​

核心公式 ​

算一个小例子 ​

PyTorch 里长什么样 ​

完整代码 ​

小结 ​

参考资料 ​