[向量函数的微分 - 小时百科](https://wuli.wiki/changed/vecdif.html)

### 向量函数是什么？
给定一个函数$\boldsymbol f(\boldsymbol x) = \boldsymbol W \boldsymbol x$
其中输入 $\boldsymbol x\in\mathbb R^n$、输出 $\boldsymbol f(\boldsymbol x)\in\mathbb R^m$、权重矩阵 $\boldsymbol w\in\mathbb R^{m\times n}$。
这个向量函数能将n维的输入向量映射到m维输出向量。

### 微分代表着什么？
与一维微分函数$dy=y'dx$一样，代表着x的微小变化会怎么影响到y。
而多维微分函数$dz = \frac{\partial z}{\partial x}\ dx + \frac{\partial z}{\partial y}\ dy$就代表着每个变量x,y的微小变化会怎么影响到z。
与向量函数结合，就是每一个变量$x_i,y_i$的微笑变化会怎么影响到$z_i$，每一行都是$dz = \frac{\partial z}{\partial x}\ dx + \frac{\partial z}{\partial y}\ dy$这样的数，共有m行
### 向量函数的全微分用矩阵表示
给定一个向量函数$f(q)=(w_{11}q_{11}+w_{12}q_2+...w_{1n}q_n,w_{21}q_1+w_{22}q_2+...w_{2n}q_n,...+w_{mn}q_n)^T$ 我们要求f对q的全微分函数，$\frac{\partial f}{\partial q} = J(q)$ ($J(q)$就是雅可比矩阵),并且写成矩阵的形式：  

$$ \boldsymbol J(\boldsymbol q) =\frac{\partial \boldsymbol f}{\partial \boldsymbol q} = \begin{bmatrix} \dfrac{\partial f_1}{\partial q_1} & \dfrac{\partial f_1}{\partial q_2} & \dots & \dfrac{\partial f_1}{\partial q_n}\\[6pt] \dfrac{\partial f_2}{\partial q_1} & \dfrac{\partial f_2}{\partial q_2} & \dots & \dfrac{\partial f_2}{\partial q_n}\\[6pt] \vdots & \vdots & \ddots & \vdots\\[6pt] \dfrac{\partial f_m}{\partial q_1} & \dfrac{\partial f_m}{\partial q_2} & \dots & \dfrac{\partial f_m}{\partial q_n} \end{bmatrix} $$

核心意义：**输出微小变化 = 雅可比矩阵 × 输入微小变化**；知道输出要变多少，就能**反向推输入该变多少**。
而这个思想在工程上被广泛的应用，这里举两个应用：
[[雅可比矩阵在机器人学中的应用]]，给定若干变量，要求机器人末端达到多少的速度，则每个变量的具体速度就能通过雅可比矩阵计算出来！
[[雅可比矩阵在神经网络中的应用]]，当神经网络要进行反向传播更新权重的时候，就需要根据雅可比矩阵计算通过链式法则计算误差和权重的梯度，进而通过梯度下降法更新权重。$\frac{\partial L}{\partial W} = \frac{\partial L}{\partial y} \frac{\partial y}{\partial W}$

雅可比矩阵数学推导

# 自由度

![image.png](https://tuchuang-yxjxxr.oss-cn-beijing.aliyuncs.com/undefinede434906a40b5dedb0285864407d503f6.image.png)


![image.png](https://tuchuang-yxjxxr.oss-cn-beijing.aliyuncs.com/undefined6e79599cd2f5037608e067151d169345.image.png)


![image.png](https://tuchuang-yxjxxr.oss-cn-beijing.aliyuncs.com/undefinedb6b5427906b243437a4c205adcdfe6f5.image.png)


![image.png](https://tuchuang-yxjxxr.oss-cn-beijing.aliyuncs.com/undefineda3b4a8963bc2bbe69c1a7b8d687273c0.image.png)

![image.png](https://tuchuang-yxjxxr.oss-cn-beijing.aliyuncs.com/undefineda40a020f576c0f18a5d87b518d30c2da.image.png)


![image.png](https://tuchuang-yxjxxr.oss-cn-beijing.aliyuncs.com/undefined681a6f87bc154808cd6a69f0b22db2c9.image.png)

![image.png](https://tuchuang-yxjxxr.oss-cn-beijing.aliyuncs.com/undefined050480aacc125dcd4491e7d891387001.image.png)


![image.png](https://tuchuang-yxjxxr.oss-cn-beijing.aliyuncs.com/undefined1776526e1f7976085333d03076f85979.image.png)

![image.png](https://tuchuang-yxjxxr.oss-cn-beijing.aliyuncs.com/undefined87666ffa27e371f9b9f7504f3de7bdcd.image.png)

![image.png](https://tuchuang-yxjxxr.oss-cn-beijing.aliyuncs.com/undefineded65c5dde0da20edc58edbb8388be710.image.png)

机器人技术基础期末复习

# 裂缝检测模型训练结果报告

> 项目：Tunnel裂缝检测  
> 时间：2026-05-14  
> 训练设备：NVIDIA GeForce RTX 2080 Ti (22GB)  
> 软件环境：Ultralytics 8.4.50, PyTorch 2.4.1, CUDA 12.1

---

## 📁 项目结构

```
tunnel/
├── train/images/          # 训练集: 3185张图片
├── train/labels/          # 训练标注
├── valid/images/          # 验证集: 442张图片
├── valid/labels/          # 验证标注
├── test/images/           # 测试集: 120张图片
├── data.yaml              # 数据集配置
├── train_tunnel.py        # 训练脚本
├── infer_tunnel.py        # 推理脚本
└── runs/                  # 训练结果目录
    └── detect/
        ├── tunnel_crack/          # 第一次训练 (YOLOv8n)
        │   ├── weights/
        │   │   ├── best.pt        # 最佳模型
        │   │   └── last.pt        # 最终模型
        │   ├── results.csv        # 训练日志
        │   ├── results.png        # 训练曲线
        │   └── confusion_matrix.png
        └── tunnel_crack-2/        # 第二次训练 (YOLO26s)
            └── ... (相同结构)
```

---

## 📊 数据集分析

### 基本信息

| 参数 | 数值 |
|------|------|
| 类别数 | 4 |
| 训练图片 | 3,185 |
| 验证图片 | 442 |
| 测试图片 | 120 |
| 图片尺寸 | 640×640 |
| 标注格式 | YOLO |

### 类别分布

#### 训练集

| 类别 | 实例数 | 占比 | 说明 |
|------|--------|------|------|
| **0** | 2,258 | 44.1% | 主要类别（裂缝） |
| **stone** | 1,115 | 21.8% | 石块/异物 |
| **2** | 963 | 18.8% | 次要裂缝类型 |
| **1** | 788 | 15.4% | 少数类别 |

**类别不平衡**: 类别0是类别1的 2.9倍

#### 验证集

| 类别 | 实例数 | 占比 |
|------|--------|------|
| **0** | 474 | 70.1% |
| **2** | 109 | 16.1% |
| **stone** | 81 | 12.0% |
| **1** | 12 | 1.8% |

---

## 🏃 训练详情

### 训练1: YOLOv8n

```python
model = YOLO("yolov8n.pt")
model.train(
    data="tunnel/data.yaml",
    epochs=100,
    imgsz=640,
    batch=32,
    device=0,
    optimizer="Adam",
    patience=20,
)
```

**训练参数**:
- 模型: YOLOv8n (YOLO第8代 nano版本)
- 参数量: ~3M
- 训练时间: 23.7分钟
- 学习率: 0.01 (Adam)
- 数据增强: Mosaic, RandAugment

**保存路径**:
- `runs/detect/runs/tunnel_crack/weights/best.pt`
- `runs/detect/runs/tunnel_crack/weights/last.pt`

---

### 训练2: YOLO26s

```python
model = YOLO("yolo26s.pt")
model.train(
    data="tunnel/data.yaml",
    epochs=100,
    imgsz=640,
    batch=32,
    device=0,
    optimizer="Adam",
    patience=20,
)
```

**训练参数**:
- 模型: YOLO26s (YOLO第26代 small版本)
- 参数量: ~9.5M
- 训练时间: 52.8分钟
- 学习率: 0.01 (Adam)
- 数据增强: Mosaic, RandAugment

**保存路径**:
- `runs/detect/runs/tunnel_crack-2/weights/best.pt`
- `runs/detect/runs/tunnel_crack-2/weights/last.pt`

---

## 📈 性能对比

### 整体性能

| 指标 | YOLOv8n | YOLO26s | 差异 |
|------|---------|---------|------|
| **参数量** | 3.0M | 9.5M | +217% |
| **训练时间** | 23.7分钟 | 52.8分钟 | +123% |
| **mAP50** | **0.570** | 0.562 | -1.4% |
| **mAP50-95** | **0.378** | 0.347 | -8.2% |
| **Precision** | **0.843** | 0.612 | -27.4% |
| **Recall** | 0.487 | 0.489 | +0.4% |
| **推理速度** | 3.0ms/张 | 3.0ms/张 | 持平 |

### 结论

- **YOLOv8n 胜出**：速度更快，精度更高
- **YOLO26s 欠拟合**：参数量大3倍，但100轮训练不足

---

## 🔍 各类别详细对比

### 类别 0（主要类别）

| 指标 | YOLOv8n | YOLO26s |
|------|---------|---------|
| Precision | **0.932** | 0.862 |
| Recall | 0.673 | **0.705** |
| mAP50 | **0.865** | 0.822 |
| mAP50-95 | **0.556** | 0.485 |

**分析**: YOLOv8n在类别0上全面领先，特别是定位精度(mAP50-95)高14.6%

---

### 类别 1（小样本）

| 指标 | YOLOv8n | YOLO26s |
|------|---------|---------|
| Precision | 0.513 | **0.658** |
| Recall | 0.583 | 0.583 |
| mAP50 | 0.499 | **0.586** |
| mAP50-95 | 0.392 | **0.393** |

**分析**: YOLO26s在小样本类别上有优势，但提升有限

---

### 类别 2

| 指标 | YOLOv8n | YOLO26s |
|------|---------|---------|
| Precision | **0.926** | 0.889 |
| Recall | **0.693** | 0.665 |
| mAP50 | **0.860** | 0.813 |
| mAP50-95 | **0.549** | 0.498 |

**分析**: YOLOv8n全面领先

---

### stone 类别

| 指标 | YOLOv8n | YOLO26s |
|------|---------|---------|
| Precision | **1.0** | 0.038 |
| Recall | **0** | 0.002 |
| mAP50 | **0.055** | 0.034 |
| mAP50-95 | **0.015** | 0.011 |

**分析**: 两个模型在stone类别上都失败，可能是数据分布问题

**原因分析**:
- 验证集只有81个stone实例（12%）
- 验证集分布与训练集不一致
- 建议检查stone样本质量或重新采样

---

## 🧪 实际推理对比

### 测试图片对比（5张）

| 图片 | YOLOv8n检测结果 | YOLO26s检测结果 | 胜者 |
|------|-----------------|-----------------|------|
| 95_png... | 1个目标, conf=0.517 | 1个目标, conf=**0.816** | YOLO26s |
| Image_-696... | 1个目标, conf=**0.774** | 1个目标, conf=0.764 | YOLOv8n |
| Image_-698... | 1个目标, conf=0.443 | 1个目标, conf=**0.669** | YOLO26s |
| Image_-702... | 1个目标, conf=**0.506** | 1个目标, conf=0.298 | YOLOv8n |
| Image_-731... | **3个目标** (0.826, 0.640, 0.264) | **0个目标** | **YOLOv8n** 🏆 |

### 关键发现

**第5张图最关键**:
```
YOLOv8n: 检测到3个目标（类别2 + 2个类别1）
YOLO26s: 完全漏检（0个目标）
```

**统计**:
| 指标 | YOLOv8n | YOLO26s |
|------|---------|---------|
| 检测到目标的图片 | **5/5** | 4/5 |
| 检测到的总目标数 | **7** | 4 |
| 多目标检测能力 | **强** | 弱 |

---

## 📉 损失函数对比

### 最终损失值（Epoch 100）

| 损失类型 | YOLOv8n | YOLO26s | 分析 |
|---------|---------|---------|------|
| box_loss | **0.902** | 1.135 | v8n定位更准 |
| cls_loss | **0.712** | 0.891 | v8n分类更准 |
| dfl_loss | 1.242 | **0.021** | s模型dfl收敛好 |

**关键发现**:
- YOLO26s的box_loss和cls_loss都比YOLOv8n高
- 说明YOLO26s**欠拟合**，100轮训练不足
- YOLO26s需要**更多训练轮数**才能发挥优势

---

## ✅ 最终结论

### 推荐模型: YOLOv8n ✅

**理由**:
1. ✅ **速度更快**: 训练时间只有一半 (23.7分钟 vs 52.8分钟)
2. ✅ **精度更高**: mAP50-95领先8.2% (0.378 vs 0.347)
3. ✅ **检测更全面**: 多目标场景表现好，不漏检
4. ✅ **Precision更高**: 0.843 vs 0.612（误检更少）

**模型路径**:
```
runs/detect/runs/tunnel_crack/weights/best.pt
```

---

### YOLO26s 失败原因

1. **训练不足**: 100轮对9.5M参数不够，建议200轮+
2. **batch可能过大**: 32对s模型可能不稳定，建议16
3. **欠拟合**: 损失函数未充分收敛

**改进方案**:
```python
model = YOLO("yolo26s.pt")
model.train(
    data="tunnel/data.yaml",
    epochs=200,        # 100 → 200
    batch=16,          # 32 → 16
    patience=50,       # 20 → 50
    # 其他参数不变
)
```

---

## 🚀 使用指南

### 加载最佳模型

```python
from ultralytics import YOLO

# 推荐：YOLOv8n
model = YOLO("runs/detect/runs/tunnel_crack/weights/best.pt")

# 验证
metrics = model.val()
print(f"mAP50: {metrics.box.map50:.4f}")

# 推理单张图片
results = model("path/to/image.jpg")
results[0].show()

# 推理文件夹
results = model("tunnel/test/images", save=True)
```

### 导出部署

```python
# 导出ONNX格式
model.export(format="onnx")

# 导出TensorRT格式（更快，需GPU）
model.export(format="engine")

# 导出CoreML格式（iOS/Mac）
model.export(format="coreml")
```

---

## 📊 性能指标速查

| 指标 | 含义 | YOLOv8n值 | 评价 |
|------|------|-----------|------|
| mAP50 | IoU=0.5时的平均精度 | 0.570 | 良好 |
| mAP50-95 | IoU=0.5:0.95平均精度 | 0.378 | 中等 |
| Precision | 精确率 | 0.843 | 优秀 |
| Recall | 召回率 | 0.487 | 一般 |
| 推理速度 | 单张图片时间 | 3.0ms | 极快 (~333 FPS) |

---

## 🔧 后续优化建议

1. **数据增强**
   ```python
   model.train(
       augment=True,
       mixup=0.1,
       copy_paste=0.1,
   )
   ```

2. **类别平衡**
   - 对类别1和stone进行过采样
   - 或使用类别权重

3. **stone类别排查**
   - 检查标注质量
   - 重新划分train/val

4. **尝试更大模型**
   - 如果YOLOv8n精度不够，可尝试YOLOv8s
   - 训练200轮+小batch

---

## 📁 附件说明

| 文件 | 说明 |
|------|------|
| `results.csv` | 每轮训练详细数据 |
| `results.png` | 训练曲线图（loss、mAP等） |
| `confusion_matrix.png` | 混淆矩阵 |
| `labels.jpg` | 数据集标签分布可视化 |
| `train_batch*.jpg` | 训练批次可视化 |
| `val_batch*_pred.jpg` | 验证集预测结果 |

---

## 📞 备注

- 训练日志保存在 `runs/detect/runs/tunnel_crack/`
- 推理结果保存在 `runs/detect/predict/`
- 使用 `tensorboard --logdir runs` 可查看训练可视化

---

*报告生成时间: 2026-05-14*  
*作者: Claude Code*  
*项目: Tunnel裂缝检测系统*

📊 训练结果分析
  三个指标含义

![image.png](https://tuchuang-yxjxxr.oss-cn-beijing.aliyuncs.com/undefined6422d30de8f2eaeac330e927742cf5dd.image.png)


  txt标注文件格式

  class_id  x_center  y_center  width  height

  示例：1 0.3667 0.5 0.2067 1.0
  - 1 = 类别1（裂缝类型）
  - 0.3667 = 目标中心X坐标（归一化0-1，相对于图片宽度）
  - 0.5 = 目标中心Y坐标（归一化0-1，相对于图片高度）
  - 0.2067 = 目标框宽度（归一化）
  - 1.0 = 目标框高度（归一化）


# IoU 与 YOLO 算法原理详解

## 目录
1. [IoU (Intersection over Union)](#iou-intersection-over-union)
2. [YOLO 算法原理](#yolo-算法原理)
3. [IoU 在 YOLO 中的应用](#iou-在-yolo-中的应用)

---

## IoU (Intersection over Union) 交并比

### 定义

IoU 是衡量**预测框**与**真实框**重叠程度的指标：

```
          交集面积 (Intersection)
IoU = ─────────────────────────────
          并集面积 (Union)
```

### 直观理解

想象两个矩形框：**预测框**是模型猜的位置，**真实框**是标注的正确位置。

```
真实框 (Ground Truth)          预测框 (Prediction)
┌──────────┐                    ┌──────────┐
│          │    交集区域         │          │
│    ┌─────┼─────────┐         │          │
│    │     │         │         │          │
│    │  ██████       │         │          │  ← 重叠部分（交集）
│    │  ██████       │         │          │
│    └─────┼─────────┘         │          │
│          │                    │          │
└──────────┘                    └──────────┘

IoU = 黑色区域面积 / (两个框总面积 - 黑色区域面积)
```

### IoU 值含义

| IoU 值 | 含义 | 检测质量 |
|--------|------|----------|
| **1.0** | 完全重合 | 完美检测 |
| **0.7** | 70% 重叠 | 优秀 |
| **0.5** | 50% 重叠 | 一般（常用阈值） |
| **0.3** | 30% 重叠 | 较差 |
| **0** | 无重叠 | 完全错误 |

### 为什么 IoU=0.5 是常用阈值？

- **平衡性**：既要求预测框大致正确，又允许一定误差
- **工程实践**：人工标注也有误差，不能太严格
- **COCO 标准**：目标检测竞赛常用 0.5 作为判断正例的阈值

---

## YOLO 算法原理

### 核心思想："You Only Look Once"

传统目标检测（如 R-CNN）：
```
图片 → 生成候选框 → 对每个框分类 → 结果
        [两步流程，慢]
```

YOLO：
```
图片 → 神经网络一次性预测所有目标 → 结果
        [一步完成，快]
```

> **关键创新**：把目标检测当作**回归问题**，直接从图片像素预测边界框坐标和类别概率。

---

### YOLO 工作流程

#### 步骤 1：网格划分 (Grid Division)

将输入图片划分为 `S × S` 的网格（如 7×7）：

```
┌──┬──┬──┬──┬──┬──┬──┐
│  │  │  │  │  │  │  │
├──┼──┼──┼──┼──┼──┼──┤
│  │  │🐶│  │  │  │  │  ← 狗的中心落在这个格子
├──┼──┼──┼──┼──┼──┼──┤
│  │  │  │  │  │  │  │
├──┼──┼──┼──┼──┼──┼──┤
│  │  │  │🚗│  │  │  │  ← 车的中心落在这个格子
├──┼──┼──┼──┼──┼──┼──┤
│  │  │  │  │  │  │  │
└──┴──┴──┴──┴──┴──┴──┘
```

**规则**：物体的中心落在哪个格子，那个格子就负责检测这个物体。

---

#### 步骤 2：每个格子预测 (Per-Cell Prediction)

**每个格子**预测 **B** 个边界框，每个框包含：

| 参数 | 说明 | 范围 |
|------|------|------|
| **x, y** | 框中心相对于格子左上角的偏移 | 0~1 |
| **w, h** | 框的宽度和高度（相对于整图） | 0~1 |
| **confidence** | 置信度（该框包含物体的概率 × IoU） | 0~1 |
| **C₁, C₂, ... Cₙ** | 各类别的概率 | 0~1 |

```
单个格子输出向量：
┌─────────────────────────────────────────────────┐
│ [x₁, y₁, w₁, h₁, conf₁, x₂, y₂, w₂, h₂, conf₂, │  ← 两个框（B=2）
│  P(cat), P(dog), P(car), ... ]                   │  ← 类别概率
└─────────────────────────────────────────────────┘
```

---

#### 步骤 3：网络输出

最终输出是一个 **3D 张量**：

```
输出尺寸 = S × S × (B × 5 + C)

S: 网格大小（如 7）
B: 每个格子预测的框数（如 2）
5: x, y, w, h, confidence
C: 类别数（如 4，对应你的裂缝数据集）

示例：7 × 7 × (2×5 + 4) = 7 × 7 × 14 = 686 个数值
```

---

#### 步骤 4：网络架构

```
输入图片 (640×640×3)
         ↓
┌─────────────────┐
│  主干网络 (Backbone)  │  ← 提取特征（卷积层）
│  如 CSPDarknet53     │
└─────────────────┘
         ↓
    特征图
         ↓
┌─────────────────┐
│  特征融合 (FPN/PAN)   │  ← 多尺度特征融合
│  检测不同大小目标     │
└─────────────────┘
         ↓
┌─────────────────┐
│  检测头 (Detection Head) │  ← 预测框和类别
└─────────────────┘
         ↓
输出 (S×S×(B×5+C))
```

---

### YOLO 的损失函数

训练时需要同时优化三个部分：

```
总损失 = λ₁ × 坐标损失 (MSE of x, y, w, h)
       + λ₂ × 置信度损失 (BCE of confidence)
       + λ₃ × 分类损失 (BCE of class probabilities)
```

| 损失类型 | 作用 | 计算公式 |
|----------|------|----------|
| **坐标损失** | 让预测框位置更准确 | (x_pred - x_true)² + (y_pred - y_true)² + (√w_pred - √w_true)² + (√h_pred - √h_true)² |
| **置信度损失** | 让模型学会判断有无物体 | 二值交叉熵 |
| **分类损失** | 让模型学会识别物体类别 | 多类别交叉熵 |

---

### 后处理：NMS (非极大值抑制)

**问题**：多个格子可能预测同一个物体，产生重叠框。

**解决步骤**：

```
1. 过滤低置信度的框（如 confidence < 0.25）
2. 按置信度从高到低排序
3. 选置信度最高的框，加入结果
4. 计算该框与其他所有框的 IoU
5. 去掉 IoU > 阈值（如 0.5）的框（认为是同一个物体）
6. 重复 3-5 直到没有框
```

**示例**：
```
初始预测：     NMS后：
┌───┐┌───┐    ┌───┐
│ 1 ││ 2 │    │ 1 │     ← 保留最高置信度
│0.9││0.7│    │0.9│
└───┘└───┘    └───┘
  ↓↓↓ IoU=0.8  去掉框2（重叠太多）
```

---

## IoU 在 YOLO 中的应用

### 1. 训练时：判断正负样本

```
对于每个预测框：
- 计算与所有真实框的 IoU
- 取最大 IoU
- 如果 Max(IoU) > 阈值(0.5)：正样本，参与坐标和分类学习
- 如果 Max(IoU) < 阈值：负样本，只学习置信度（置信度→0）
```

### 2. 推理时：NMS 去重

```
高 IoU 的框认为是同一个物体，只保留置信度最高的。
```

### 3. 评估时：计算 mAP

```
mAP50：IoU 阈值设为 0.5 时的平均精度
mAP50-95：IoU 阈值从 0.5 到 0.95 的平均精度（更严格）
```

---

## YOLO 版本演进

| 版本 | 年份 | 主要改进 |
|------|------|----------|
| **YOLOv1** | 2016 | 开创性，首次提出单阶段检测 |
| **YOLOv2** | 2017 | 引入 Anchor Boxes，Batch Normalization |
| **YOLOv3** | 2018 | 多尺度预测（3个尺度），Darknet-53 |
| **YOLOv4** | 2020 | 大量优化技巧（Mish激活、CIOU等） |
| **YOLOv5** | 2020 | PyTorch实现，工程友好，Ultralytics |
| **YOLOv8** | 2023 | Anchor-free设计，解耦头，C2f模块 |
| **YOLOv10** | 2024 | 端到端检测，去除NMS，实时性更强 |
| **YOLO26** | 2025 | 最新架构，你的训练模型 |

---

## 总结

### IoU 是什么？
- 衡量两个框重叠程度的指标
- 范围 0~1，1 表示完全重合
- 常用阈值 0.5 判断检测是否正确

### YOLO 怎么做检测？
1. 把图片切成网格
2. 每个格子预测多个框（位置+置信度+类别）
3. 神经网络一次性输出所有预测
4. 用 NMS 去除重复框
5. 得到最终结果

### 两者的关系
- **IoU** 是 YOLO 的"评分标准"：判断预测好坏
- **YOLO** 是"考生"：不断调整使 IoU 越来越高

---

## 参考资源

- [YOLO 原始论文](https://arxiv.org/abs/1506.02640)
- [Ultralytics YOLO 文档](https://docs.ultralytics.com/)
- [IoU 详解 - 知乎](https://zhuanlan.zhihu.com/p/47189358)

---

*文档创建时间：2026-05-14*
*基于 YOLO26 训练日志分析*

tunnel检测

完整启动流程

终端 1：启动地图服务器
```bash
cd /home/HwHiAiUser/project_new/src/map/
ros2 run nav2_map_server map_server --ros-args -p yaml_filename:=./map.yaml
```

等待输出：
```
[INFO] [...] [map_server]\: map_server lifecycle node launched.
[INFO] [...] [map_io]\: Read map ./map.pgm: 193 X 217 map @ 0.05 m/cell
```

--

终端 2：激活地图服务器
```bash
ros2 run nav2_util lifecycle_bringup map_server
```

等待输出：
```
[INFO] [...] [map_server]\: Activating
[INFO] [...] [map_io]\: Map loaded successfully
```

--

终端 3：验证地图（可选）
```bash
ros2 topic echo /map --once
```

--

终端 4：运行 A* 路径规划节点
```bash
cd /home/HwHiAiUser/project_new/src/map/
python3 astar_rviz.py
```

等待输出：
```
[INFO] [...] [astar_rviz]\: 地图接收成功: 193x217
[INFO] [...] [astar_rviz]\: 路径发布成功: 161 个点
```

--


终端 5：RViz2 可视化（可选）
```bash
rviz2
```

RViz2 设置：
1. Fixed Frame → `map`
2. Add → By topic → `/map` → Map
3. Add → By topic → `/astar_path` → Path

--

快速检查清单

| 步骤 | 命令 | 预期结果 |
|------|------|----------|
| 1. 启动地图服务器 | `ros2 run nav2_map_server map_server ...` | "Read map ./map.pgm" |
| 2. 激活地图 | `ros2 run nav2_util lifecycle_bringup map_server` | "Map loaded successfully" |
| 3. 运行 A* 节点 | `python3 astar_rviz.py` | "路径发布成功: XX 个点" |
| 4. RViz2 显示 | `rviz2` | 显示地图和红色路径 |

按顺序执行，每个步骤等上一个成功后再执行下一个！🚀