你是否被这些概念搞得头晕眼花？
- 机器学习、深度学习、神经网络是什么关系？
- CNN、RNN、LSTM、Transformer有什么区别？
- YOLOv8用的是什么技术？
别担心！这篇文章带你理清这些概念的关系，从基础到前沿一网打尽！
📚 目录
- 一、概念层级关系总览
- 二、机器学习：AI的基石
- 三、神经网络：模拟人脑的计算模型
- 四、深度学习：多层神经网络的力量
- 五、CNN：图像处理的王者
- 六、RNN与LSTM：序列数据的利器
- 七、Transformer：自然语言处理的革命
- 八、YOLOv8：目标检测的SOTA
- 九、技术选型指南
一、概念层级关系总览
1.1 核心概念关系图
人工智能 AI
机器学习 ML
深度学习 DL
神经网络 NN
CNN
卷积神经网络
RNN
循环神经网络
Transformer
注意力机制
LSTM
长短期记忆网络
YOLOv8
目标检测
GPT/BERT
大语言模型
1.2 层级关系详解
第五层：应用模型
YOLOv8
GPT
BERT
第四层：具体架构
CNN
RNN
Transformer
第三层：深度学习
DL = 多层神经网络学习
第二层：机器学习
ML = 从数据中学习规律
第一层：人工智能
AI = 机器模拟人类智能
1.3 核心概念对比
| 概念 | 定义 | 核心思想 | 典型应用 |
|---|---|---|---|
| 人工智能 | 机器模拟人类智能 | 让机器像人一样思考 | 智能助手、自动驾驶 |
| 机器学习 | 从数据中学习规律 | 数据驱动决策 | 推荐系统、预测分析 |
| 深度学习 | 多层神经网络学习 | 自动特征提取 | 图像识别、NLP |
| 神经网络 | 模拟人脑的计算模型 | 神经元连接计算 | 各种AI任务 |
二、机器学习：AI的基石
2.1 什么是机器学习？
数据
机器学习算法
模型
预测/决策
传统编程
规则 + 数据 = 结果
机器学习
数据 + 结果 = 规则
核心定义：
机器学习（Machine Learning） 是人工智能的一个子领域，它让计算机能够从数据中自动学习规律，而无需显式编程。
2.2 机器学习的三大类型
机器学习
监督学习
无监督学习
强化学习
分类
回归
聚类
降维
游戏AI
机器人控制
三大类型详解：
| 类型 | 特点 | 数据要求 | 典型算法 |
|---|---|---|---|
| 监督学习 | 有标签数据 | 输入+输出 | 线性回归、决策树、SVM |
| 无监督学习 | 无标签数据 | 仅输入 | K-Means、PCA |
| 强化学习 | 奖励机制 | 环境+动作 | Q-Learning、DQN |
2.3 经典机器学习算法
python
# 监督学习示例：线性回归
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
# 1. 准备数据
X, y = load_data() # 特征和标签
X_train, X_test, y_train, y_test = train_test_split(X, y)
# 2. 训练模型
model = LinearRegression()
model.fit(X_train, y_train)
# 3. 预测
predictions = model.predict(X_test)
# 4. 评估
score = model.score(X_test, y_test)
python
# 无监督学习示例：K-Means聚类
from sklearn.cluster import KMeans
# 1. 准备数据
X = load_data() # 仅特征，无标签
# 2. 训练模型
kmeans = KMeans(n_clusters=3)
kmeans.fit(X)
# 3. 获取聚类结果
labels = kmeans.labels_
centroids = kmeans.cluster_centers_2.4 机器学习 vs 深度学习
深度学习
原始数据
自动特征提取
神经网络
端到端学习
预测结果
机器学习
原始数据
人工特征提取
传统算法
预测结果
核心区别：
| 维度 | 机器学习 | 深度学习 |
|---|---|---|
| 特征提取 | 人工设计 | 自动学习 |
| 数据需求 | 较少 | 大量 |
| 计算资源 | CPU即可 | 需要GPU |
| 可解释性 | 高 | 低 |
| 适用场景 | 结构化数据 | 非结构化数据 |
三、神经网络：模拟人脑的计算模型
3.1 神经网络的灵感来源
人工神经元
输入
x1, x2, ...
加权求和
Σw·x + b
激活函数
σ
输出
y
生物神经元
树突
接收信号
细胞体
处理信号
轴突
传递信号
突触
连接其他神经元
3.2 单个神经元的计算
输出层
激活层
计算层
输入层
x1
x2
x3
w1
w2
w3
bias
激活函数
ReLU/Sigmoid
y
Σ w·x + b
数学公式：
y = f(Σ(wi × xi) + b)
其中：
- xi: 输入特征
- wi: 权重
- b: 偏置
- f: 激活函数3.3 常见激活函数
激活函数
Sigmoid
Tanh
ReLU
Leaky ReLU
Softmax
输出范围: 0-1
用于二分类
输出范围: -1到1
用于隐藏层
输出范围: 0到∞
最常用
解决ReLU死神经元问题
输出概率分布
用于多分类
激活函数代码示例：
python
import numpy as np
def sigmoid(x):
"""Sigmoid激活函数"""
return 1 / (1 + np.exp(-x))
def relu(x):
"""ReLU激活函数"""
return np.maximum(0, x)
def softmax(x):
"""Softmax激活函数"""
exp_x = np.exp(x - np.max(x)) # 防止溢出
return exp_x / np.sum(exp_x)
# 使用示例
x = np.array([-2, -1, 0, 1, 2])
print("Sigmoid:", sigmoid(x))
print("ReLU:", relu(x))
print("Softmax:", softmax(x))3.4 多层神经网络（MLP）
输出层
隐藏层2
隐藏层1
输入层
x1
x2
x3
h1
h2
h3
h4
h5
h6
h7
y1
y2
MLP代码示例：
python
import torch
import torch.nn as nn
class MLP(nn.Module):
"""
多层感知机（Multi-Layer Perceptron）
结构：输入层 -> 隐藏层1 -> 隐藏层2 -> 输出层
"""
def __init__(self, input_size, hidden_size, output_size):
super(MLP, self).__init__()
self.layer1 = nn.Linear(input_size, hidden_size)
self.layer2 = nn.Linear(hidden_size, hidden_size)
self.layer3 = nn.Linear(hidden_size, output_size)
self.relu = nn.ReLU()
self.softmax = nn.Softmax(dim=1)
def forward(self, x):
x = self.relu(self.layer1(x))
x = self.relu(self.layer2(x))
x = self.softmax(self.layer3(x))
return x
# 使用示例
model = MLP(input_size=784, hidden_size=256, output_size=10)
x = torch.randn(32, 784) # batch_size=32
output = model(x)
print(output.shape) # torch.Size([32, 10])四、深度学习：多层神经网络的力量
4.1 什么是深度学习？
深度学习
核心特点
多层神经网络
自动特征提取
端到端学习
大数据驱动
深度 = 多个隐藏层
无需人工设计特征
输入到输出一体化
数据越多效果越好
核心定义：
深度学习（Deep Learning） 是机器学习的一个子领域，使用多层神经网络自动学习数据的层次化表示。
4.2 深度学习的"深"体现在哪里？
深度网络
输入
隐藏层1
隐藏层2
隐藏层3
...
输出
浅层网络
输入
隐藏层
输出
层次化特征学习：
图像识别的层次化特征：
┌─────────────────────────────────────────┐
│ 第1层：边缘、线条 │
├─────────────────────────────────────────┤
│ 第2层：简单形状（圆、方、三角） │
├─────────────────────────────────────────┤
│ 第3层：复杂形状（眼睛、耳朵、轮子） │
├─────────────────────────────────────────┤
│ 第4层：物体部件 │
├─────────────────────────────────────────┤
│ 第5层：完整物体 │
└─────────────────────────────────────────┘4.3 深度学习的三大支柱
深度学习成功要素
大数据
算力
算法
ImageNet
千万级标注数据
互联网数据
海量文本/图像
GPU并行计算
TPU专用芯片
CNN架构
Transformer架构
优化算法
Adam/SGD
4.4 深度学习训练流程
否
是
准备数据
构建模型
定义损失函数
选择优化器
训练循环
前向传播
计算损失
反向传播
更新参数
收敛?
模型评估
部署应用
训练代码示例：
python
import torch
import torch.nn as nn
import torch.optim as optim
# 1. 准备数据
train_loader = get_data_loader()
# 2. 构建模型
model = MLP(input_size=784, hidden_size=256, output_size=10)
# 3. 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
# 4. 训练循环
for epoch in range(100):
for batch_x, batch_y in train_loader:
# 前向传播
outputs = model(batch_x)
# 计算损失
loss = criterion(outputs, batch_y)
# 反向传播
optimizer.zero_grad()
loss.backward()
# 更新参数
optimizer.step()
print(f"Epoch {epoch}, Loss: {loss.item():.4f}")五、CNN：图像处理的王者
5.1 CNN的核心思想
CNN核心思想
局部感受野
权重共享
池化降维
只关注局部区域
模拟人眼视觉
同一卷积核扫描全图
减少参数量
保留重要特征
减少计算量
5.2 CNN架构详解
输出
全连接层
池化层
卷积层
输入
图像
224×224×3
Conv1
提取边缘
Conv2
提取形状
Conv3
提取纹理
MaxPool
降维
MaxPool
降维
FC1
FC2
分类结果
5.3 卷积操作详解
计算过程
卷积核在图像上滑动
逐元素相乘后求和
卷积操作
输入图像
5×5
卷积核
3×3
特征图
3×3
卷积计算示例：
输入图像（5×5）: 卷积核（3×3）:
┌───┬───┬───┬───┬───┐ ┌───┬───┬───┐
│ 1 │ 2 │ 3 │ 4 │ 5 │ │ 1 │ 0 │-1 │
├───┼───┼───┼───┼───┤ ├───┼───┼───┤
│ 6 │ 7 │ 8 │ 9 │10 │ │ 1 │ 0 │-1 │
├───┼───┼───┼───┼───┤ ├───┼───┼───┤
│11 │12 │13 │14 │15 │ │ 1 │ 0 │-1 │
├───┼───┼───┼───┼───┤ └───┴───┴───┘
│16 │17 │18 │19 │20 │
├───┼───┼───┼───┼───┤
│21 │22 │23 │24 │25 │
└───┴───┴───┴───┴───┘
第一个位置的卷积结果:
1×1 + 2×0 + 3×(-1) +
6×1 + 7×0 + 8×(-1) +
11×1 + 12×0 + 13×(-1)
= 1 - 3 + 6 - 8 + 11 - 13 = -65.4 池化操作详解
示例
┌───┬───┬───┬───┐
│ 1 │ 3 │ 2 │ 4 │
├───┼───┼───┼───┤
│ 5 │ 6 │ 7 │ 8 │
├───┼───┼───┼───┤
│ 9 │10 │11 │12 │
├───┼───┼───┼───┤
│13 │14 │15 │16 │
└───┴───┴───┴───┘
→
┌───┬───┐
│ 6 │ 8 │
├───┼───┤
│14 │16 │
└───┴───┘
最大池化
输入
4×4
2×2窗口
步长2
输出
2×2
5.5 CNN代码实现
python
import torch
import torch.nn as nn
class SimpleCNN(nn.Module):
"""
简单的CNN网络
结构：
Conv -> ReLU -> Pool -> Conv -> ReLU -> Pool -> FC
"""
def __init__(self, num_classes=10):
super(SimpleCNN, self).__init__()
# 卷积层1
self.conv1 = nn.Conv2d(
in_channels=3, # 输入通道数（RGB图像）
out_channels=32, # 输出通道数（卷积核数量）
kernel_size=3, # 卷积核大小
stride=1, # 步长
padding=1 # 填充
)
self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
# 卷积层2
self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
# 全连接层
self.fc1 = nn.Linear(64 * 56 * 56, 512) # 假设输入图像为224×224
self.fc2 = nn.Linear(512, num_classes)
self.relu = nn.ReLU()
self.dropout = nn.Dropout(0.5)
def forward(self, x):
# 卷积块1
x = self.conv1(x)
x = self.relu(x)
x = self.pool1(x)
# 卷积块2
x = self.conv2(x)
x = self.relu(x)
x = self.pool2(x)
# 展平
x = x.view(x.size(0), -1)
# 全连接层
x = self.fc1(x)
x = self.relu(x)
x = self.dropout(x)
x = self.fc2(x)
return x
# 使用示例
model = SimpleCNN(num_classes=10)
x = torch.randn(32, 3, 224, 224) # batch=32, channels=3, height=224, width=224
output = model(x)
print(output.shape) # torch.Size([32, 10])5.6 经典CNN架构演进
1998 LeNet-5 手写数字识别 5层网络 2012 AlexNet ImageNet冠军 8层网络，ReLU 2014 VGGNet 小卷积核堆叠 16-19层 2014 GoogLeNet Inception模块 22层 2015 ResNet 残差连接 152层 2017 DenseNet 密集连接 特征复用 2020 EfficientNet 复合缩放 效率最优 CNN架构演进史
六、RNN与LSTM：序列数据的利器
6.1 为什么需要RNN？
传统神经网络的问题
输入固定长度
无法处理序列
忽略时序信息
RNN的优势
处理变长序列
记忆历史信息
捕捉时序依赖
RNN的典型应用：
| 应用场景 | 输入 | 输出 |
|---|---|---|
| 机器翻译 | 源语言句子 | 目标语言句子 |
| 语音识别 | 音频序列 | 文字序列 |
| 文本生成 | 前文 | 后续文字 |
| 股票预测 | 历史价格 | 未来价格 |
6.2 RNN架构详解
展开形式
x1
h1
x2
h2
x3
h3
y1
y2
y3
RNN核心公式：
ht = tanh(Wxh × xt + Whh × ht-1 + bh)
yt = Why × ht + by
其中：
- xt: t时刻的输入
- ht: t时刻的隐藏状态（记忆）
- yt: t时刻的输出
- W: 权重矩阵6.3 RNN的问题：梯度消失
小于1
大于1
梯度反向传播
链式法则
连续相乘
梯度大小
梯度消失
长距离依赖丢失
梯度爆炸
参数更新过大
6.4 LSTM：解决长距离依赖
信息流
上一时刻状态
LSTM单元
当前时刻状态
下一时刻
LSTM单元
输入门
决定哪些信息存入细胞
遗忘门
决定丢弃哪些信息
细胞状态
长期记忆
输出门
决定输出哪些信息
LSTM三大门控：
| 门控 | 作用 | 取值范围 |
|---|---|---|
| 遗忘门 | 决定丢弃哪些旧信息 | 0-1 |
| 输入门 | 决定存入哪些新信息 | 0-1 |
| 输出门 | 决定输出哪些信息 | 0-1 |
6.5 LSTM代码实现
python
import torch
import torch.nn as nn
class SimpleLSTM(nn.Module):
"""
LSTM网络
用于序列数据处理
"""
def __init__(
self,
input_size, # 输入特征维度
hidden_size, # 隐藏层维度
num_layers=2, # LSTM层数
num_classes=10 # 分类数
):
super(SimpleLSTM, self).__init__()
self.hidden_size = hidden_size
self.num_layers = num_layers
# LSTM层
self.lstm = nn.LSTM(
input_size=input_size,
hidden_size=hidden_size,
num_layers=num_layers,
batch_first=True,
dropout=0.5
)
# 全连接层
self.fc = nn.Linear(hidden_size, num_classes)
def forward(self, x):
# x shape: (batch_size, seq_len, input_size)
# 初始化隐藏状态
h0 = torch.zeros(
self.num_layers,
x.size(0),
self.hidden_size
).to(x.device)
c0 = torch.zeros(
self.num_layers,
x.size(0),
self.hidden_size
).to(x.device)
# LSTM前向传播
# out shape: (batch_size, seq_len, hidden_size)
out, (hn, cn) = self.lstm(x, (h0, c0))
# 取最后一个时间步的输出
out = out[:, -1, :]
# 分类
out = self.fc(out)
return out
# 使用示例
model = SimpleLSTM(input_size=128, hidden_size=256, num_classes=10)
x = torch.randn(32, 50, 128) # batch=32, seq_len=50, input_size=128
output = model(x)
print(output.shape) # torch.Size([32, 10])6.6 RNN vs LSTM vs GRU
序列模型对比
RNN
LSTM
GRU
简单快速
长距离依赖差
长距离依赖好
参数多，计算慢
简化版LSTM
参数少，速度快
对比总结：
| 模型 | 参数量 | 训练速度 | 长距离依赖 | 适用场景 |
|---|---|---|---|---|
| RNN | 少 | 快 | 差 | 短序列 |
| LSTM | 多 | 慢 | 好 | 长序列 |
| GRU | 中 | 中 | 好 | 长序列（效率优先） |
七、Transformer：自然语言处理的革命
7.1 Transformer的诞生
2014 Seq2Seq 编码器-解码器 2015 Attention机制 Bahdanau注意力 2017 Transformer 《Attention Is All You Need》 2018 BERT 双向编码器 2018 GPT 单向解码器 2020 GPT-3 1750亿参数 2022 ChatGPT RLHF对齐 2023 GPT-4 多模态 NLP架构演进
7.2 Transformer核心架构
解码器
编码器
输入嵌入
位置编码
多头注意力
前馈网络
输出嵌入
位置编码
掩码多头注意力
编码器-解码器注意力
前馈网络
输出
7.3 自注意力机制详解
自注意力机制
Query Q
Key K
Value V
Q × K^T
计算相似度
Softmax
归一化
× V
加权求和
输出
自注意力公式：
Attention(Q, K, V) = softmax(Q × K^T / √dk) × V
其中：
- Q: Query矩阵（查询）
- K: Key矩阵（键）
- V: Value矩阵（值）
- dk: Key的维度（用于缩放）7.4 多头注意力
输入
多头注意力
Head 1
Head 2
Head 3
Head 4
Concat
Linear
输出
多头注意力的优势：
- 每个头关注不同的语义信息
- 捕捉多种类型的依赖关系
- 增强模型表达能力
7.5 Transformer代码实现
python
import torch
import torch.nn as nn
import math
class MultiHeadAttention(nn.Module):
"""
多头自注意力机制
"""
def __init__(self, d_model, num_heads):
super(MultiHeadAttention, self).__init__()
assert d_model % num_heads == 0
self.d_model = d_model
self.num_heads = num_heads
self.d_k = d_model // num_heads
# Q, K, V的线性变换
self.W_q = nn.Linear(d_model, d_model)
self.W_k = nn.Linear(d_model, d_model)
self.W_v = nn.Linear(d_model, d_model)
# 输出线性变换
self.W_o = nn.Linear(d_model, d_model)
def forward(self, x, mask=None):
batch_size = x.size(0)
# 线性变换
Q = self.W_q(x)
K = self.W_k(x)
V = self.W_v(x)
# 分割多头
Q = Q.view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
K = K.view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
V = V.view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
# 计算注意力分数
scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_k)
# 应用掩码（可选）
if mask is not None:
scores = scores.masked_fill(mask == 0, -1e9)
# Softmax归一化
attention = torch.softmax(scores, dim=-1)
# 加权求和
output = torch.matmul(attention, V)
# 合并多头
output = output.transpose(1, 2).contiguous().view(batch_size, -1, self.d_model)
# 输出线性变换
output = self.W_o(output)
return output
class TransformerEncoderLayer(nn.Module):
"""
Transformer编码器层
"""
def __init__(self, d_model, num_heads, d_ff, dropout=0.1):
super(TransformerEncoderLayer, self).__init__()
self.attention = MultiHeadAttention(d_model, num_heads)
self.feed_forward = nn.Sequential(
nn.Linear(d_model, d_ff),
nn.ReLU(),
nn.Linear(d_ff, d_model)
)
self.norm1 = nn.LayerNorm(d_model)
self.norm2 = nn.LayerNorm(d_model)
self.dropout = nn.Dropout(dropout)
def forward(self, x, mask=None):
# 多头注意力 + 残差连接 + LayerNorm
attention_output = self.attention(x, mask)
x = self.norm1(x + self.dropout(attention_output))
# 前馈网络 + 残差连接 + LayerNorm
ff_output = self.feed_forward(x)
x = self.norm2(x + self.dropout(ff_output))
return x
class TransformerEncoder(nn.Module):
"""
Transformer编码器
"""
def __init__(
self,
vocab_size,
d_model,
num_heads,
num_layers,
d_ff,
max_seq_len,
dropout=0.1
):
super(TransformerEncoder, self).__init__()
# 词嵌入
self.embedding = nn.Embedding(vocab_size, d_model)
# 位置编码
self.positional_encoding = self._create_positional_encoding(
max_seq_len, d_model
)
# 编码器层
self.layers = nn.ModuleList([
TransformerEncoderLayer(d_model, num_heads, d_ff, dropout)
for _ in range(num_layers)
])
self.dropout = nn.Dropout(dropout)
def _create_positional_encoding(self, max_seq_len, d_model):
"""创建位置编码"""
pe = torch.zeros(max_seq_len, d_model)
position = torch.arange(0, max_seq_len, dtype=torch.float).unsqueeze(1)
div_term = torch.exp(
torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)
)
pe[:, 0::2] = torch.sin(position * div_term)
pe[:, 1::2] = torch.cos(position * div_term)
return pe.unsqueeze(0)
def forward(self, x, mask=None):
# 词嵌入 + 位置编码
x = self.embedding(x)
x = x + self.positional_encoding[:, :x.size(1), :].to(x.device)
x = self.dropout(x)
# 通过编码器层
for layer in self.layers:
x = layer(x, mask)
return x
# 使用示例
model = TransformerEncoder(
vocab_size=10000,
d_model=512,
num_heads=8,
num_layers=6,
d_ff=2048,
max_seq_len=512
)
x = torch.randint(0, 10000, (32, 100)) # batch=32, seq_len=100
output = model(x)
print(output.shape) # torch.Size([32, 100, 512])7.6 Transformer vs RNN
Transformer
并行计算
训练快
全局注意力
长距离依赖好
RNN
串行计算
训练慢
长距离依赖差
梯度消失
核心优势对比：
| 维度 | RNN/LSTM | Transformer |
|---|---|---|
| 计算方式 | 串行 | 并行 |
| 训练速度 | 慢 | 快 |
| 长距离依赖 | 差 | 好 |
| 参数量 | 少 | 多 |
| 内存占用 | 低 | 高 |
八、YOLOv8：目标检测的SOTA
8.1 目标检测任务
目标检测任务
定位
分类
边界框
Bounding Box
类别标签
Class Label
输出: 物体位置 + 类别
8.2 YOLO系列演进
2016 YOLOv1 开创性工作 单阶段检测 2017 YOLOv2/YOLO9000 Batch Normalization Anchor Boxes 2018 YOLOv3 多尺度检测 Darknet-53 2020 YOLOv4 CSPDarknet 数据增强 2020 YOLOv5 PyTorch实现 易用性提升 2022 YOLOv6/YOLOv7 工业优化 速度提升 2023 YOLOv8 Anchor-Free 性能最优 YOLO系列演进史
8.3 YOLOv8架构详解
检测头Head
颈部网络Neck
骨干网络Backbone
输入图像
640×640×3
CSPDarknet
特征提取
PANet
特征融合
小目标检测
80×80
中目标检测
40×40
大目标检测
20×20
检测结果
边界框 + 类别
8.4 YOLOv8核心创新
YOLOv8创新点
Anchor-Free
解耦头
Mosaic增强
Task Aligned Assigner
无需预设锚框
减少超参数
分类和回归分离
提高精度
数据增强
提高泛化能力
动态样本匹配
提高正样本质量
8.5 YOLOv8代码实现
python
from ultralytics import YOLO
import cv2
# 1. 加载预训练模型
model = YOLO('yolov8n.pt') # nano版本，速度快
# 2. 训练模型
results = model.train(
data='coco.yaml', # 数据集配置
epochs=100, # 训练轮数
imgsz=640, # 图像大小
batch=16, # 批大小
name='yolov8_custom' # 实验名称
)
# 3. 验证模型
metrics = model.val()
print(f"mAP50: {metrics.box.map50}")
print(f"mAP50-95: {metrics.box.map}")
# 4. 推理
results = model('image.jpg')
# 5. 可视化结果
for result in results:
# 获取边界框
boxes = result.boxes
for box in boxes:
# 边界框坐标
x1, y1, x2, y2 = box.xyxy[0]
# 类别和置信度
cls = int(box.cls[0])
conf = float(box.conf[0])
print(f"类别: {cls}, 置信度: {conf:.2f}, 位置: ({x1:.0f}, {y1:.0f}, {x2:.0f}, {y2:.0f})")
# 6. 保存结果
result.save('result.jpg')8.6 YOLOv8与其他检测器对比
目标检测器
两阶段
单阶段
R-CNN系列
精度高
速度慢
YOLO系列
SSD
RetinaNet
速度快
精度高
性能对比：
| 模型 | mAP50-95 | FPS (V100) | 参数量 |
|---|---|---|---|
| YOLOv8n | 37.3% | 330 | 3.2M |
| YOLOv8s | 44.9% | 170 | 11.2M |
| YOLOv8m | 50.2% | 90 | 25.9M |
| YOLOv8l | 52.9% | 60 | 43.7M |
| YOLOv8x | 53.9% | 40 | 68.2M |
8.7 YOLOv8中的CNN架构
YOLOv8使用的技术
CNN骨干网络
特征金字塔FPN
注意力机制
CSPDarknet
残差连接
PANet
多尺度融合
SPPF
空间金字塔池化
九、技术选型指南
9.1 架构选择决策树
图像
分类
检测
分割
序列/文本
分类
生成
理解
时间序列
短
长
很长
选择架构
数据类型?
任务类型?
CNN
YOLOv8
U-Net
任务类型?
Transformer
GPT
BERT
序列长度?
RNN
LSTM/GRU
Transformer
9.2 各架构适用场景总结
YOLO适用场景
实时检测
自动驾驶
安防监控
工业检测
Transformer适用场景
大语言模型
机器翻译
文本理解
多模态任务
RNN/LSTM适用场景
语音识别
机器翻译
文本生成
时间序列预测
CNN适用场景
图像分类
目标检测
图像分割
人脸识别
9.3 技术栈关系总结
AI技术栈
机器学习
监督学习
无监督学习
强化学习
深度学习
神经网络
CNN
图像处理
YOLOv8
RNN
序列处理
LSTM
Transformer
注意力机制
GPT/BERT
应用领域
计算机视觉
图像分类
目标检测
自然语言处理
文本分类
机器翻译
语音处理
语音识别
语音合成
9.4 学习路径建议
入门
Python基础
机器学习基础
深度学习基础
神经网络
CNN
RNN/LSTM
Transformer
计算机视觉
序列建模
NLP/LLM
YOLOv8
GPT/BERT
总结
核心概念关系回顾
人工智能
机器学习
深度学习
神经网络
CNN
图像处理
RNN/LSTM
序列处理
Transformer
注意力机制
YOLOv8
目标检测
GPT/BERT
大语言模型
关键要点
- 层级关系：AI ⊃ ML ⊃ DL ⊃ NN
- CNN：图像处理的王者，核心是卷积和池化
- RNN/LSTM：序列数据的利器，LSTM解决长距离依赖
- Transformer：NLP的革命，核心是自注意力机制
- YOLOv8：目标检测的SOTA，融合CNN和最新技术
面试加分话术
-
展示深度理解：
"CNN的核心思想是局部感受野和权重共享，这大大减少了参数量。Transformer通过自注意力机制实现了全局依赖建模，解决了RNN的串行计算问题。"
-
展示实践能力：
"我在项目中使用YOLOv8进行目标检测，通过数据增强和模型微调，将mAP从70%提升到85%。同时使用Transformer构建了文本分类模型。"
-
展示学习能力：
"我持续关注最新的技术发展，如Vision Transformer将Transformer应用于图像领域，以及YOLOv8的Anchor-Free设计。"
文档版本 : v1.0
最后更新 : 2024年
作者: E教千问技术团队
参考资料
经典论文
- Attention Is All You Need (Transformer, 2017)
- YOLOv8 (2023)
- Long Short-Term Memory (LSTM, 1997)