神经网络知识点

深度学习框架

Tensorflow
Keras
PyTorch
Paddle

什么是深度学习？

深度学习是更深的神经网络。结构仍是输入层 → 隐藏层 → 输出层，不是另起一套算法。

和传统神经网络相同

端到端黑盒，可解释性较差。
自己完成特征提取，不必手抠特征。

不同：强调深度

浅层网隐藏层少；深度学习把层叠深。GoogleNet 约 22 层，ResNet 可到 50 / 101 / 152。层数是经典结构的公开规格。

神经网络的结构是怎样的？

三层：输入接数据，隐藏做特征，输出对齐任务。层与层之间是带权重的边；训练改的就是这些 W 和 b。

输入层 — 神经元个数 = 特征维度。只负责接数，通常不做激活。
隐藏层 — 一层或多层。每个神经元：加权求和 + 激活。层数和宽度是超参；深度学习就是把这里叠深。
输出层 — 个数对齐任务：二分类 1 个（或 2 个），K 类就是 K 个，再接 Softmax。回归常常 1 个线性输出。

最基础是全连接（MLP）：上一层每个点和下一层都连。CNN / RNN / Transformer 是换连接方式，三层角色还在。

什么是激活函数？

本层神经元吃上一层的输出。输入层通常把特征原样往下传；从隐藏层开始，上层输出和下层输入之间隔着一个函数，这个函数就叫激活函数。

重点为什么需要激活函数？

不用激活就等于 f(x)=x。每一层都是上一层的线性函数，叠多少层，输出仍是输入的线性组合，和没有隐藏层一样。加上非线性，网络才能逼近几乎任意函数，不再只是加权求和。

常见激活函数有哪些？

Sigmoid — 输出 (0, 1)，见下一节。
Tanh — 输出 (-1, 1)，零中心，见下一节。
ReLU — max(0, x)，见下一节。
Leaky ReLU — 负半轴留一小斜率，缓解死 ReLU。
Softmax — 多类输出层，把 Logits 收成和为 1 的概率。

Sigmoid 有什么特点？

把任意实数压到 (0, 1)。负无穷趋近 0，正无穷趋近 1。公式：σ(x) = 1 / (1 + e^{-x})。

python

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

导数 σ'(x) = σ(x)(1-σ(x))，最大约 0.25（在 σ=0.5 处）。反向传播是梯度连乘：权在 [0,1] 时，每过一层最多再乘 0.25，层一深就趋近 0，叫梯度消失。权初始化大于 1 才可能梯度爆炸，深网里消失更常见。所以隐藏层别用它当默认，二分类输出有时还用。

Tanh 有什么特点？

双曲正切。值域 (-1, 1)，奇函数，过原点。公式：tanh(x) = (e^x - e^{-x}) / (e^x + e^{-x})。曲线和 Sigmoid 像，差一个缩放平移（tanh(x) = 2σ(2x) - 1）。

python

def tanh(x):
    return (np.exp(x) - np.exp(-x)) / (np.exp(x) + np.exp(-x))

比 Sigmoid 好训，关键是零中心：输出均值约 0。Sigmoid 恒大于 0，下一层输入带着偏置偏移（bias shift），梯度下降更慢。原点附近接近 y=x。仍会饱和，深网照样梯度消失。归一化回归（标签在 [-1,1]）常和 L2 一起用。深网隐藏层默认还是 ReLU。

ReLU 有什么特点？

单侧抑制。relu(x) = x if x>0 else 0。负数全打成 0，正数原样过。被激活时（x>0）导数恒为 1，误差几乎不衰减地往回传，不像 Sigmoid 每层最多乘 0.25。信号传得到，权就能持续更新，深网学得又快又稳。隐藏层默认它。

python

def relu(x):
    return np.maximum(0, x)

负半轴梯度为 0，神经元可能「死掉」（Dead ReLU），这时上 Leaky ReLU。Sigmoid / Tanh 挤在 (0,1) 或 (-1,1)，适合当概率或有界输出，但不适合深隐藏层。

重点什么是梯度消失？

反向传播要更新浅层（比如 b1），梯度从 loss 一层层乘回来。三层、每层一个神经元、激活是 Sigmoid：y = σ(wx+b)。|σ'| ≤ 0.25，再乘 |w|<1，每层因子 < 0.25。小于 1 的数连乘，传到输入附近就接近 0。

现象 — 靠近输出的隐藏层梯度还正常，权能更新；越靠近输入，更新越慢甚至停住。整网看起来在训，其实只等价于后面几层浅网在学，收敛停滞。
何时明显 — 深网 + Sigmoid / Tanh。误差每过一层衰减一次。
同理会爆炸 — |w| 过大时 |σ'w| > 1，大于 1 的数连乘就是梯度爆炸。

缓解：隐藏层换 ReLU（x>0 导数为 1）、残差、BN、合理初始化。

什么是梯度爆炸？

反向传播把各层导数连乘。若每层 |W| · |f'| 经常大于 1，梯度一层层放大，浅层更新步子飞掉，loss 变 NaN。和消失是同一条链式法则，只是乘积小于 1 还是大于 1。

何时容易炸 — 权初始化偏大（大于 1）、层很深、RNN 沿时间步连乘。Sigmoid 导数 ≤0.25，单独它更常消失；权一大，仍可能炸。
和消失对比 — 消失：浅层几乎不更新。爆炸：一步走太远，训练崩。深网里 Sigmoid 路线消失更常见。
怎么压 — 梯度裁剪（clip）；Xavier / He 初始化；残差、BN；隐藏层换 ReLU。

前向传播是什么？

数据从输入层一路算到输出层，只算预测，不改权重。推理就是一遍前向；训练时先前向出 loss，再反向传梯度。

每一层两步：

text

z = Wx + b      # 线性加权
a = f(z)        # 激活（ReLU / Softmax 等）

a 交给下一层当 x。分类任务最后一层往往出 Logits，再 Softmax / argmax。BERT 微调那次前向打分类分，就是这条路。

怎么用 numpy 模拟前向传播？

三步：初始化 W/b → 定义激活 → 逐层 z = a_prev @ W + b，再 a = g(z)。不调框架，手写一遍证明你会算。

示例：3 层。隐藏层 Sigmoid，输出层恒等 g(x)=x（回归演示，不是 Softmax）。有的材料把线性结果叫 a、激活结果叫 z，和公式反了。约定是 z 线性、a 激活。

python

def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def forward(network, x):
    z1 = np.dot(x, network["W1"]) + network["b1"]
    a1 = sigmoid(z1)
    z2 = np.dot(a1, network["W2"]) + network["b2"]
    a2 = sigmoid(z2)
    z3 = np.dot(a2, network["W3"]) + network["b3"]
    return z3  # 恒等，y = z3

W 的形状要对上：x 长度 × 下一层神经元数。代码是行向量 x @ W，和公式 Wx 只是行列约定不同。

从0编写一个神经网络的步骤

不调框架时按三步搭骨架，第三步里再转训练循环。常用随机数把流程跑通：样本 64，输入 10000，隐藏 100，输出 10。

定义网络结构 — 指定输入 / 隐藏 / 输出的宽度。上面这组：W1 (10000, 100)，W2 (100, 10)。
初始化模型参数 — W、b 随机初始化（Xavier / He），不要全零。
循环操作
- 3.1 前向传播
- 3.2 计算损失函数
- 3.3 后向传播（链式法则）
- 3.4 权值更新

数据可用 numpy.random 生成占位。输出 10 维时 loss 用交叉熵更贴分类；只为验证矩阵形状，也可用 MSE。

前馈神经网络的训练过程是哪三步？

前馈网就是数据单向往前流、没有环。每一轮训练就三步（loss 算在前向末尾）。

前向 — 逐层算状态 z 和激活 a，直到最后一层，得到 ŷ，再和标签比出 loss。
反向 — 链式法则算每一层参数的偏导 ∂L/∂W、∂L/∂b。
更新 — 优化器按梯度改参数（SGD / Adam）。

搭骨架（定宽、初始化）在循环外面，见上一节。推理只做第 1 步。

损失函数是干什么的？

衡量预测和真值差多远，非负标量。训练的目标就是把它压小；反向传播从它倒回去。

二分类交叉熵（BCE） — L = -(y log ŷ + (1-y) log(1-ŷ))，再对 m 条取平均。ŷ 一般是 Sigmoid 概率。分类用这个，别用 MSE 打 0/1。
MAE — (1/m) Σ |ŷ − y|。回归，对异常点不那么敏感。
MSE — (1/(2m)) Σ (ŷ − y)²。平方放大离谱误差；前面 1/2 是求导好看（和 (ŷ−y) 约掉）。

多分类把 BCE 换成 Softmax + 交叉熵。 loss 必须能反传，别用不可导的准确率当训练目标。

重点反向传播是什么？

用链式法则，从 loss 这一头往回走，算出每个节点、每个 W/b 对最终结果的影响力（梯度）。有了梯度再微调参数，这一步才叫学习。推理只前向，没有反向。

从结果往回算 — 不是从输入猜，是从 ∂L 一层层乘本地的 f'(z) 和 x。
影响力 = 梯度 — ∂L/∂W 大，说明这个权对错得多，更新步子该大。
学习 = 按梯度改参 — W ← W - lr * ∇W。反向只负责方向，迈步是优化器的事。

连乘小于 1 会消失，大于 1 会爆炸。公式拆解看面试题里的链式法则。

梯度下降怎么把误差传回隐藏层？

梯度下降要每一层都有误差才能改那一层的 W。输出层误差好算（预测减真值）；难点是怎么把这份误差分给隐藏层。

按连接分摊 — 隐藏节点 c 连到输出 e、f，它的误差就和 e、f 都有关。教材常按权重（或权重平方）占比切开：权越大，摊到的输出误差越多。
W 双向当通道 — 前向：W 传递输入信号。反向：输出误差经 W 的转置 传回隐藏层，再去更新连到隐藏层的那些权。
迈步 — 有了每层梯度：W ← W - lr * ∇W。lr 太大震荡，太小爬不动。

工程实现是 δ_h = (W^T δ_o) ⊙ f'(z_h)，不是手算那串占比公式。

梯度下降有哪些优化器？

反向只给出方向，怎么迈步是优化器的事。都还是梯度下降家族，差在要不要动量、学习率要不要按参数自适应。

SGD — 收敛快，容易进局部最优。方向只看当前 batch，抖。
Momentum — 保留上一拍方向，当前梯度只微调，模拟惯性，少震荡。
AdaGrad — 自适应学习率：很少更新的参数用较大 α，常更新的用较小 α。历史平方和一直累加，后期步子会过小。
RMSprop — 历史梯度改成滑动平均，缓解 AdaGrad 学习率掉太快。
Adam — 动量 + 二阶自适应（Momentum 和 RMSprop 那一路）。稀疏梯度、噪声大时稳，深度学习里最常用。

神经网络在机器学习里怎么摆？

原理小结。网络当万能函数：做复杂特征变换，或逼近复杂条件分布。写成 ŷ = g(φ(x), θ)。

φ(x) — 神经网络，把原始 x 变成好用的表示。
g(·) — 分类器 / 回归头，吃表示出预测。
g 是 Logistic 回归 — 逻辑回归就是网络的最后一层（Sigmoid + 线性）。BERT 加分类头，也是前面抽特征、最后一层做 g。

分布式训练的基本方式是什么？

主流是数据并行：每张卡一份完整模型，数据切开，各自算梯度，再同步更新同一份权。单卡放得下的 CNN / BERT 走这条。

单机多卡 — tf.distribute.MirroredStrategy，卡之间镜像一份权。
多机多卡 — MultiWorkerMirroredStrategy。
参数服务器 — 一部分机器只存参数，其余机器算梯度。适合权特别大、镜像一份都费劲的时候。

和模型并行别混：数据并行是切 batch，模型并行是切 模型本身。

如何进行模型并行？

一张卡塞不下整个模型时，把不同层拆到不同 GPU 上跑。前向按层接力：GPU0 算出 hidden，再送到 GPU1。适合显存不够的超大模型。

TensorFlow 可用 tf.device 手动指定：

python

with tf.device("/GPU:0"):
    layer1 = Dense(128)(inputs)
with tf.device("/GPU:1"):
    layer2 = Dense(10)(layer1)

按层切更接近 流水线并行（PP）。还有一种 张量并行（TP）：一层里的大矩阵切到多张卡，vLLM 的 --tensor-parallel-size / SGLang 的 --tp-size 是这个。先说「模型切开放多卡」，再拆 PP / TP。

和数据并行怎么选

	数据并行	模型并行
怎么切	每张卡一份完整模型，各吃不同 batch	模型本身切开，一张卡只放一部分
适用	常规模型，单卡放得下（CNN、BERT）	单卡放不下（DeepSeek-R1 一类）

TensorFlow 里计算图和会话怎么管？

图是节点（算子）+ 边（张量）的数据流，描述谁依赖谁。1.x 要先建图再用 Session 跑；2.x 默认 Eager，要加速再 @tf.function 描成图。会话这个词是 1.x 的，现在默认不再天天用 tf.Session()。

图的好处 — 算子融合；无依赖节点可并行（GPU / 多核）；图在 C++ 里跑，少和 Python 来回；能导出到端侧 / Serving。

python

a = tf.constant(2)
b = tf.constant(3)
c = a + b          # 静态图思维：先搭图，不立刻算

张量 — 多维数组，在图上流动，自动求导、可上 GPU。

维数	叫法	例子
0	标量	`3.0`
1	向量	`[1, 2, 3]`
2	矩阵	`[[1, 2], [3, 4]]`
3+	高维	图 `[高, 宽, 通道]`

2.x 怎么配合

Eager — 默认，像 NumPy 逐行跑，print(a+b) 直接是 5，好调试。
@tf.function — 第一次调用描成图，之后走图。循环、矩阵密计算更快；可导出 SavedModel 给 Serving。

python

@tf.function
def add_and_multiply(x, y):
    return x + y, x * y

TensorFlow Serving 是什么？

TensorFlow 官方的生产级推理服务。把训好的 SavedModel 封成 REST / gRPC，业务只打 HTTP，不在进程里 model.predict()。版本号当子目录，可热加载、回滚。端上是 TensorFlow Lite，别和 Serving 混成一个东西。大模型生成式推理走 vLLM / SGLang。

PyTorch 是什么？

NumPy + GPU。NumPy 接口熟，但只能跑 CPU，数据一大就慢。PyTorch 的 Tensor 用法几乎一样（ones / zeros / 加减乘），差别是能搬到显卡上算。研究、大模型、HuggingFace 生态默认它。

python

import torch
x = torch.Tensor([[1, 2, 3], [4, 5, 6]])
x = torch.zeros(3)
x = torch.from_numpy(np.ones(3))
x = x.to("cuda")   # 搬到 GPU

「快几十倍」是社区口径。

PyTorch 里 Tensor 怎么运算？

加减乘除、幂、按维求和，和 NumPy 同一套直觉。注意 dim：0 按列，1 按行。x.op() 和 torch.op(x) 一般等价。

python

x = torch.Tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
x.pow(-1)              # 逐元素求倒数
x.pow(2)               # 逐元素平方
x.sum(dim=0)           # 按列求和 → [12, 15, 18]
x.sum(dim=1)           # 按行求和 → [6, 15, 24]
inv = x.sum(dim=1).pow(-1)
inv.diag_embed()       # 向量拉成对角矩阵

torch.nn.functional 里常用什么？

F = torch.nn.functional，卷积、池化、激活、Dropout 都是现成算子。卷积和反向的导数不必手推；底层 C++ / CUDA，别用 Python 循环自己卷。

函数	干什么
`F.conv1d` / `F.conv2d`	一维 / 二维卷积（语音 vs 图像）
`F.relu`	ReLU 激活，`inplace` 默认 False
`F.max_pool1d` / `F.max_pool2d`	最大池化
`F.dropout`	训练时按概率 `p`（默认 0.5）置零；`training=True` 才丢

nn.Conv2d 是带可学习权的模块；F.conv2d 要自己传入 weight。组网常用 nn.*，前向里临时算一次用 F.*。「快几百倍」是社区口径。

PyTorch 怎么用？

和从 0 写网络同一套：定结构 → 初始化 → 循环四步。换成 Tensor + nn.Module + autograd，反传导不用手推。

定义网络结构 — 继承 nn.Module，forward 里叠层。
初始化参数 — nn.Linear 创建时就带 W/b；需要再指定 Xavier / He。
循环（每个 batch / epoch）
- 3.1 前向：ŷ = model(x)
- 3.2 算 loss
- 3.3 反向：先 optimizer.zero_grad()，再 loss.backward()
- 3.4 更新：optimizer.step()

漏 zero_grad 梯度会跨 batch 累加。推理只做 3.1，并 model.eval()。

PyTorch 的分布式训练

多卡仍是数据并行——每卡一份完整模型，切 batch，梯度再同步。和 TF 的 Mirrored / MultiWorker 同一思路，只是 API 换成 DP / DDP。PyTorch 好用也因为：Tensor + autograd、动态图（运行时建图，RNN / GAN 好调）、nn 层 + optim 优化器。单卡放得下才走这条；放不下仍是模型并行。

	`nn.DataParallel`（DP）	`DistributedDataParallel`（DDP）
范围	单机多卡	单机或多机多卡
写法	`nn.DataParallel(model, device_ids=[0, 1])` 包一层	`init_process_group(backend="nccl")` 再 `DDP(model, device_ids=[local_rank])`
怎么同步	主卡汇总梯度再广播	每卡自己算梯度，再 AllReduce 聚合
问题	主卡负载不均，效率偏低	官方更推荐；单机多卡也优先 DDP

Lightning 把进程组、设备这些藏起来，设 accelerator / devices 就能拉多卡：

python

trainer = Trainer(accelerator="gpu", devices=4, strategy="ddp")
trainer.fit(model)

TensorFlow 和 PyTorch 怎么比？

都是深度学框架，差在封装和计算图。Keras 一句 model.fit() 像自动挡；PyTorch 要自己写循环，像手动挡（Lightning 也能 fit，不是只有 TF 能一行训）。TF 1.x 静态图重，2.x 默认 Eager，部署再 @tf.function 描图；PyTorch 动态图，if/else 就能改结构，好调 RNN / GAN。

	TensorFlow（Keras）	PyTorch
上手	`fit()` 搭积木	自己写前向 / loss / backward / step
图	静态图历史包袱重；2.x 能 Eager	动态图，跟 Python 直觉走
调试	报错栈深，不好跟	能逐步 Debug
更合适	传统工业落地：Serving、TFLite、TF.js	研究、大模型、HuggingFace

「顶会九成、ChatGPT 用 PyTorch」是社区 / 公开口径。大模型上线推理走 vLLM / SGLang，不是 TF Serving。

传统图像识别有什么特点？

分步流水线，特征靠人抠。 不是端到端：获取 → 预处理 → 特征提取 → 分类器，每段单独设计。深度学习把「特征 + 分类」收进一张网里训。

数据获取 — 相机 / 图档把像素喂进来。
预处理 — 滤波、平滑、增强、复原、提边缘、分割，先把图洗干净。
特征提取 — 人定规则：幅度、统计、几何、变换系数；SIFT / HOG 是这类。路牌上画出的关键点就是 SIFT。
决策分类 — 特征进 SVM 等分类器，和提特征是两套东西。

特点：可解释、换场景要重做特征；光照、尺度一变，手工特征容易挂。

传统视觉检测和深度学习检测怎么比？

工业检测里，传统是规则卡尺，深度是 CNN 自己看。颜色、面积、圆度、角度、长宽比这类好量化的量，Halcon / VisionPro / OpenCV 写规则就够；光照、变色、曲面、视野一变，规则就要重写，同款不同批次也难一套打天下。

	传统视觉检测	深度学习检测
怎么判	特征工程 + 规则，符不符合标准	深度网络端到端，主流是 CNN
擅长	好提取、能量化的量	传统难稳定的变化（光、色、曲面、视野）
短板	物体或批次一变，规则算法都要重做	要大数据；工业采数贵、标注贵
补短板	—	先数据增强；无监督、自动标注多是研究在推

卷积神经网络（CNN）是什么？

CNN 是人工神经网络的一种，MLP 的变种：不全连接，改成局部感受野 + 权共享。灵感来自 Hubel / Wiesel 看猫的视觉皮层。

感受野 — 皮层细胞只对视野里一块局部敏感，像滤波器铺满视野，挖边缘、朝向这类空间关系。
S 细胞（Simple Cell） — 在自己的感受野里对边缘类刺激最敏感 → 对应卷积核扫局部模式。
C 细胞（Complex Cell） — 感受野更大，模式挪一点还能响应 → 对应池化，换位置也能认出。

输入层 → 隐藏层 → 输出层还在，变的是层怎么连。

卷积神经网络的结构是怎样的？

核心就两句：局部连接 + 权共享。一块邻域接到下一层一个点；滤波器滑到别处，同一组 W 和 b 共用。卷积核也叫 kernel / filter / feature detector，扫完得到特征图（Feature Map / Activation Map）。

2×2 核扫到左上角：

text

y = w1·x0 + w2·x1 + w3·x4 + w4·x5 + b

滑到下一个窗口，还是这四个 w 和同一个 b。MLP 每个位置一套权；CNN 全图共用一套，参数少，换位置也能认出同一模式。

nn.Conv2d 先记四个：

参数	干什么
`in_channels`	输入通道，RGB 是 3
`out_channels`	输出通道 = 核的个数 = 特征图张数
`kernel_size`	核大小，`3` 或 `(3, 3)`
`stride` / `padding`	步长、补边，管输出空间尺寸

dilation、groups 追问再补。

CNN 的本质是什么？

多层拼图。 浅层卷积（S 细胞）抠小碎片：横线、竖线、圆弧；池化（C 细胞）把位置上的小抖动抹掉；再往上叠，线拼成眼、眼拼成脸、脸拼成人。从局部到整体、从简单到复杂。

MLP 一上来就全连接，空间结构散了，也堆不出这套层次。传统视觉是人先定碎片长什么样；CNN 碎片自己学。

YOLO 和 CNN 是什么关系？

不是二选一。CNN 是零件，YOLO 是方案。 CNN 只负责看图、抽特征（横线、竖线、眼睛、耳朵）；YOLO（You Only Look Once）把一堆卷积按检测任务装起来，既要认是什么，还要给出框（坐标）。

	CNN	YOLO
角色	技术组件	检测架构 / 解决方案
干什么	提特征	特征 + 分类 + 定位
比喻	砖	用砖盖的楼

骨干仍可以是 CNN（现在也有 Transformer 骨干）。上 YOLO 并不是换掉卷积。

重点 YOLO 是怎么做检测的？

把检测当成回归：一个网络同时出位置和类别，one-stage，训和测都看整张图。骨干用 CNN 抽特征，v1 再接全连接出预测。结构参考 GoogLeNet：约 24 个卷积 + 2 个全连接（论文规格）。卷积里常用 1×1 降维再跟 3×3；中间层 Leaky ReLU（max(x, 0.1x)），最后一层线性。输入 448×448，输出 S×S×(5B+C)；VOC 上 S=7、B=2、C=20，就是 7×7×30。

每个格子：B 个框，每框 (x, y, w, h, confidence)，再加 C 维类别概率。

loss 不能均权

只加定位 + 分类 → 框和类别量纲不同，不能当一回事平均。
再加上置信度 → 置信度分两种：格子里有没有目标。
定稿：定位误差加重；有目标的框置信度正常训；空框置信度压低，免得背景刷分；最后加分类误差。

和滑窗、区域提议（Fast R-CNN 这类两阶段）不同：没有先提框再分类的长流程，所以快。看整图，背景当物体的情况更少（论文说相对 Fast R-CNN 约少一半。Fast YOLO 把卷积从 24 收到 9，核也更少，其余设定一样，换速度。

什么是非极大值抑制（NMS）？

名字就是字面意思——把不是局部极大的框压掉。YOLO 一张图会出 n 个框，再给每个框类别分。同一辆车常常套一堆框，后处理按这一类的分数排序，留极大、掐重叠。重叠用 IoU：IoU = (A ∩ B) / (A ∪ B)。框对不上人工标注 100%，IoU 也用来评定位准不准。

按类做，阈值常见 0.5（约定，不是自己调出来的最优）：

在这类框里取出分最高的，留下（box_best）。
算它和其余框的 IoU。
IoU 过阈值 → 当成同一目标，丢掉。
在剩下的框里再取最高分，循环到空。

车上 6 个框，按「是车」的概率从小到大 A～F，F 最高：先留 F，B、D 和 F 重叠超阈值就扔；剩下 A、C、E 里 E 最高，再拿 E 去掐和它太近的；直到留完。阈值太大：挤在一起的两辆可能并成一辆；太小：一辆车留一堆框。

YOLO 用在哪些场景？

凡是要实时框出物体的地方都能用。卖点是快（一阶段、整图一看），不是精度榜第一。下面是常见方向，

自动驾驶 — 车、人、交通标志，给决策当感知。
安防监控 — 视频里盯可疑人或物。
机器人视觉 — 认周围物体并给出位置，导航、抓取。
智能交通 — 流量、违章。
产线质检 — 缺陷当目标来检；成像和 PLC 闭环见下一节，别停在「上 YOLO」。

产线质检不是只调模型。图拍不好、数存不住、检完不动作，再好的 CNN 也是实验室分数。通常就两块：硬件成像和数据 / 产线闭环。

硬件：先把图拍稳

算法吃的是像素。同一缺陷换灯、换距、换角度，特征就漂，模型当新问题。成像比换骨干重要。

相机 — 分辨率、帧率、彩色/黑白、面阵/线扫。节拍卡死时，清晰度和速度要一起谈：看清最小缺陷要多少像素，产线速度要多少 fps。
镜头 — 焦距、景深、畸变、工作距离。曲面、高低差大，景深不够边缘就糊。
光源 — 环形、条形、同轴、背光，看缺陷类型选。划痕要打出阴影，破损、缺料常用背光看轮廓。光不稳，后面全是假缺陷。
安装 — 位置、角度、数量。多工位、多面要几套相机；振动、反光、遮挡会直接毁一致性。工装夹持也算硬件：件没摆正，模型背锅。

数据与产线：检完要进系统

有没有录进数据 — OK / NG 图、时间、工位、批次要落盘。没有回流，模型漂了不知道，也没有再训练的料。误报件最好单独存，给人复判。
有没有和 PLC 打通 — 明显缺陷要报警、剔料、停线，不能只弹个 UI。检测是感知，PLC / 工控是执行。协议（常见 Modbus / OPC UA / 厂家 SDK）、节拍内给不给得出结果、超时怎么办，都要定。
指标跟代价走 — 漏检出厂贵 → 召回优先；误剔砸产能 → 精确率也要盯。这是产线约束，不是 mAP 榜。

成像稳、数据闭环、PLC 能动作，然后才是检测头。算法是中间一截。

黑白相机还是彩色？

工业视觉默认黑白。算法多半吃灰度；只有颜色本身是特征（色差、印刷偏色）才上彩。

同标称分辨率下，黑白有效精度更高：彩相机是 Bayer 插值，每个像素只采一个颜色通道。边缘、细疵（划痕、崩边）黑白更合适。

手机像素高，是不是比工业相机好？

不是。差在传感器面积，不在海报上的像素数。

手机芯片大约指甲盖大；工业相机哪怕几百万像素，靶面也常有邮票那么大。靶面大 → 进光多 → 同样亮度能高速拍，低照度还能成像。手机这时已经糊、噪、拖影。工业相机贵在靶面、快门、接口稳定。

光源怎么选？

灯的种类决定缺陷「显不显」，比换网络重要。四种先记用途：

类型	常被比作喻	怎么打	典型缺陷
环形光	无影灯	360° 均匀；高角度亮视场、低角度暗视场	通用外观、PCB、标签字符；划痕用低角度
条形光	乐高积木	单条或 2–4 条拼矩形，侧打 / 俯打，角度最自由	表面不平、大面积划痕、金属裂纹
背光	皮影戏	灯在工件背后，相机看黑色剪影	尺寸、边缘崩缺、孔堵、引脚缺失
线光	扫描仪	一条极亮线，配线阵相机	连续钢板 / 布匹 / 玻璃，高速滚筒表面

光照角度怎么选？

感光芯片进光越多图越亮。灯选对了还要调距离和角度，现场调试比买灯重要。

直射光 — 光线几乎直接进相机，被挡住的地方成黑色剪影，适合轮廓、遮挡。
反射光 — 先打到工件再进相机。镜面反射（金属高光、过曝）和漫反射（塑料、纸）不是一种打法。

为什么说缺陷检测是软硬结合？

三个人合作，不是算法一个人的项目。

硬件 / 打光 — 相机、镜头、灯、安装。
算法 — 规则或 CNN，经常在办公室甚至异地，现场把图传回来再训。这种离线很常见。
自动化 / PLC — 触发、剔料、报警。

图里缺陷看不清，准确率上不去时：死磕模型、加参、加深，公开量级大约只再涨 0.1%；现场换盏几百块的灯，图质上去一大截（图质约 50%、准确率约 10%），代码甚至不用改。

YOLO 进化史与工业检测地位

深度学习检测最大痛点是速度。YOLO（You Only Look Once）冲的就是实时：快、泛化还行。系列约 13 个版本，v1 定调（一阶段、整图回归），后面都是在它上面改。v4 / v5 作者已和前三代不是同一拨；原作者后来宣布退出 CV。旁支 Yolact（2019）做实时实例分割，不是同一条检测主线。

为什么工业检测默认先想 YOLO

点	公开规格
速度	GPU 上约 5～15ms/张，产线常要 <100ms，卡得住节拍
精度	mAP 持续抬，多数固定缺陷类够用
易用	Ultralytics 封装狠，大约 3 行能开训
部署	可导出 ONNX / TensorRT / OpenVINO，边上工控机友好
生态	社区大、教程和预训练多

重点实际项目里 YOLO 和 VLM 怎么选？

懂了 Qwen-VL 这类 VLM 之后，别二选一互踩。产线题先问三件事：节拍卡不死？要不要像素级框？类别固不固定？

一句话选型

产线实时、类固定、要框位置（剔料 / 机械臂）→ YOLO 主力。
缺标注、新缺陷试探、要文字解释 / 报告 / 复审助手 → VLM 辅助。
常见落地：YOLO 卡节拍做检测；可疑件或新品种丢给 VLM 写原因，人再抽检。不是「有了大模型就不用检测头」。

八维对比

维度	YOLO（专用检测）	VLM（如 Qwen-VL）
输出	精确 bbox + 类 + 置信度	自然语言描述 + 缺陷判断
速度	~10ms/张（GPU）	~2～5s/张（API 量级）
定位	像素级框	无框或很粗
数据	要标，常数百～数千张	零样本，改 Prompt
新类	采数 + 重训	改 Prompt
成本	本地，无按次 API 费	API 费或大显存自部署
离线	完全可离线	常要网（除非本地部署）
可解释	框和分，直观	能写「为什么」

谁擅长什么

YOLO 擅长	VLM 擅长
产线实时（速度硬约束）	新产品 / 新缺陷快速验证（先不训）
精确定位（引导机械臂剔除）	缺陷分析与报告（自然语言）
缺陷类已知且固定	辅助人工复审（给参考意见）
边缘 / 工控机部署	复杂场景关联理解（光、环境、缺陷一起说）

钢铁产线那套 YOLO + VLM + 审核台演练见质检课件（仓库内课程练习，不对外发布）。

神经网络知识点 ​

深度学习框架 ​

什么是深度学习？ ​

神经网络的结构是怎样的？ ​

什么是激活函数？ ​

重点 为什么需要激活函数？ ​

常见激活函数有哪些？ ​

Sigmoid 有什么特点？ ​

Tanh 有什么特点？ ​

ReLU 有什么特点？ ​

重点 什么是梯度消失？ ​

什么是梯度爆炸？ ​

前向传播是什么？ ​

怎么用 numpy 模拟前向传播？ ​

从0编写一个神经网络的步骤 ​

前馈神经网络的训练过程是哪三步？ ​

损失函数是干什么的？ ​

重点 反向传播是什么？ ​

梯度下降怎么把误差传回隐藏层？ ​

梯度下降有哪些优化器？ ​

神经网络在机器学习里怎么摆？ ​

分布式训练的基本方式是什么？ ​

如何进行模型并行？ ​

TensorFlow 里计算图和会话怎么管？ ​

TensorFlow Serving 是什么？ ​

PyTorch 是什么？ ​

PyTorch 里 Tensor 怎么运算？ ​

torch.nn.functional 里常用什么？ ​

PyTorch 怎么用？ ​

PyTorch 的分布式训练 ​

TensorFlow 和 PyTorch 怎么比？ ​

传统图像识别有什么特点？ ​

传统视觉检测和深度学习检测怎么比？ ​

卷积神经网络（CNN）是什么？ ​

卷积神经网络的结构是怎样的？ ​

CNN 的本质是什么？ ​

YOLO 和 CNN 是什么关系？ ​

重点 YOLO 是怎么做检测的？ ​

什么是非极大值抑制（NMS）？ ​

YOLO 用在哪些场景？ ​

黑白相机还是彩色？ ​

手机像素高，是不是比工业相机好？ ​

光源怎么选？ ​

光照角度怎么选？ ​

为什么说缺陷检测是软硬结合？ ​

YOLO 进化史与工业检测地位 ​

重点 实际项目里 YOLO 和 VLM 怎么选？ ​

神经网络知识点

深度学习框架

什么是深度学习？

神经网络的结构是怎样的？

什么是激活函数？

重点为什么需要激活函数？

常见激活函数有哪些？

Sigmoid 有什么特点？

Tanh 有什么特点？

ReLU 有什么特点？

重点什么是梯度消失？

什么是梯度爆炸？

前向传播是什么？

怎么用 numpy 模拟前向传播？

从0编写一个神经网络的步骤

前馈神经网络的训练过程是哪三步？

损失函数是干什么的？

重点反向传播是什么？

梯度下降怎么把误差传回隐藏层？

梯度下降有哪些优化器？

神经网络在机器学习里怎么摆？

分布式训练的基本方式是什么？

如何进行模型并行？

TensorFlow 里计算图和会话怎么管？

TensorFlow Serving 是什么？

PyTorch 是什么？

PyTorch 里 Tensor 怎么运算？

torch.nn.functional 里常用什么？

PyTorch 怎么用？

PyTorch 的分布式训练

TensorFlow 和 PyTorch 怎么比？

传统图像识别有什么特点？

传统视觉检测和深度学习检测怎么比？

卷积神经网络（CNN）是什么？

卷积神经网络的结构是怎样的？

CNN 的本质是什么？

YOLO 和 CNN 是什么关系？

重点 YOLO 是怎么做检测的？

什么是非极大值抑制（NMS）？

YOLO 用在哪些场景？

黑白相机还是彩色？

手机像素高，是不是比工业相机好？

光源怎么选？

光照角度怎么选？

为什么说缺陷检测是软硬结合？

YOLO 进化史与工业检测地位

重点实际项目里 YOLO 和 VLM 怎么选？