### 介绍
下面是基于pytorch的神经网络基本框架代码，这里的任务是让神经网络拟合sin函数
```
import torch
import torch.nn as nn

# ===== 0. 造数据：拟合 y = sin(x) 这个非线性函数 =====
torch.manual_seed(0)
x = torch.linspace(-3.14, 3.14, 200).unsqueeze(1)   # [200, 1]
y = torch.sin(x)                                     # [200, 1]

# 1.定义模型(万能骨架)
class MLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(1,32)
        self.fc2 = nn.Linear(32,32)
        self.fc3 = nn.Linear(32,1)
    def forward(self,x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        return self.fc3(x)

model = MLP()

# ===== 2. 损失函数 + 优化器 =====
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

# 3. 训练循环，经典5步走
for epoch in range(2000):
    optimizer.zero_grad()
    pred = model(x)
    loss = criterion(pred, y)
    loss.backward()
    optimizer.step()
    if epoch%100==0:
        print(f'当前第{epoch}轮，loss为{loss.item():.6f}')

# 4. 检验学习结果
test_x = torch.tensor([[0.0], [1.5708], [-1.5708]]) # 0,π/2, -π/2
test_pred = model(test_x)
print("预测 sin(0)   =", round(test_pred[0].item(), 4), " 真实 =", 0.0)
print("预测 sin(π/2) =", round(test_pred[1].item(), 4), " 真实 =", 1.0)
print("预测 sin(-π/2)=", round(test_pred[2].item(), 4), " 真实 =", -1.0)


```

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

神经网络基本框架代码

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

## 一、全连接层在算什么？
一个 `nn.Linear(in, out)` 就是一次矩阵运算：

$$\mathbf{y} = \mathbf{W}\mathbf{x} + \mathbf{b}$$

- $\mathbf{x}$：输入（in 维）
- $\mathbf{W}$：权重矩阵（**out × in**），要学习
- $\mathbf{b}$：偏置（out 维），要学习
- $\mathbf{y}$：输出（out 维）

**单个神经元展开**：

$$y = w_1x_1 + w_2x_2 + \dots + w_nx_n + b$$

> 验证：`nn.Linear(1,32)` 的 `weight.shape = (32,1)`，`bias.shape = (32,)`，
> 正好把 1 维输入升到 32 维。
## 二、为什么必须加激活函数？

只堆 `Wx+b`，无论多少层，**本质还是线性**（矩阵连乘还是一个矩阵），
画不出 sin 这样的弯曲曲线。

加 ReLU 引入非线性：

$$\text{ReLU}(x) = \max(0, x)$$

多层 + 非线性 → 能拟合任意复杂函数（**万能逼近定理**）。  

下面为神经网络基本框架
```python
class MLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(1, 32)
        self.fc2 = nn.Linear(32, 32)
        self.fc3 = nn.Linear(32, 1)
    def forward(self, x):
        x = torch.relu(self.fc1(x))   # 线性 + 非线性
        x = torch.relu(self.fc2(x))
        return self.fc3(x)            # 回归任务最后一层不加激活
```

## 三、训练五步骨架（雷打不动）

```python
for epoch in range(1000):
    optimizer.zero_grad()       # 1. 清空上轮梯度（梯度会累加，不清会错）
    pred = model(x)             # 2. 前向（自动调用 forward）
    loss = criterion(pred, y)   # 3. 算误差
    loss.backward()             # 4. 反向（autograd 自动算所有梯度）
    optimizer.step()            # 5. 按梯度更新参数
# 上述的代码是全批量训练的，因为数据量小
```


以上就是神经网络训练的基本流程了，后续会根据不同的任务更新不同的算法，敬请期待~

神经网络入门

## 1. $y=\arcsin x$
$$y=\arcsin x \implies x=\sin y$$ 两边对 $x$ 求导： 

$$\cos y \cdot y' = 1 \implies y'=\frac{1}{\cos y}$$

$$\cos y=\sqrt{1-\sin^2y}=\sqrt{1-x^2}$$

$$\therefore (\arcsin x)'=\frac{1}{\sqrt{1-x^2}}$$


## 2. $y=\arctan x$
$$y=\arctan x \implies x=\tan y$$

 两边对 $x$ 求导： 
 
$$\frac{1}{\cos^2 y} \cdot y' = 1 \implies y'=\cos^2 y$$

$$\cos^2 y=\frac{1}{1+x^2}$$


$$\therefore (\arctan x)'=\frac{1}{1+x^2}$$

## 3. 公式汇总：
$$\boldsymbol{(\arcsin x)'=\dfrac{1}{\sqrt{1-x^2}}}$$ 

$$\boldsymbol{(\arccos x)'=-\dfrac{1}{\sqrt{1-x^2}}}$$

$$\boldsymbol{(\arctan x)'=\dfrac{1}{1+x^2}}$$ 

$$\boldsymbol{(\text{arccot}\,x)'=-\dfrac{1}{1+x^2}}$$

反三角函数求导

# CBAM注意力机制原理详解

## 🎯 注意力机制用在模型的哪里？

### YOLOv8网络结构

```
输入图片 [B, 3, 640, 640]
         ↓
┌──────────────────────────────────────┐
│ Backbone（主干特征提取网络）           │
│                                      │
│ Conv → Conv → C2f → Conv → C2f →    │
│         ↓                            │
│     ★ CBAM                           │ ← 添加位置1：特征提取后
│         ↓                            │    增强特征表示能力
│ Conv → C2f → Conv → C2f → SPPF →    │
│         ↓                            │
│     ★ CBAM                           │ ← 添加位置2：最大特征层
│                                      │
│ 输出：多尺度特征 [P3, P4, P5]         │
└──────────────────────────────────────┘
         ↓
┌──────────────────────────────────────┐
│ Neck（特征融合网络）                   │
│                                      │
│ Upsample → Concat → C2f →            │
│         ↓                            │
│     ★ CBAM                           │ ← 添加位置3：融合后增强
│         ↓                            │    增强多尺度融合效果
│ Upsample → Concat → C2f →            │
│         ↓                            │
│     ★ CBAM                           │ ← 添加位置4：小目标检测增强
│                                      │
└──────────────────────────────────────┘
         ↓
┌──────────────────────────────────────┐
│ Head（检测头）                         │
│                                      │
│ Detect → 输出检测结果                 │
│ [类别, 置信度, bbox]                  │
│                                      │
└──────────────────────────────────────┘
```

### CBAM添加位置（共8处）

| 位置 | 网络部分 | 作用 | 特征尺寸 |
|------|---------|------|---------|
| **Backbone-3** | P2层 | 增强小特征提取 | 128通道 |
| **Backbone-6** | P3层 | 增强中等特征 | 256通道 |
| **Backbone-9** | P4层 | 增强大特征 | 512通道 |
| **Backbone-13** | P5层 | 增强最大特征 | 1024通道 |
| **Head-17** | Neck-P4 | 增强特征融合 | 512通道 |
| **Head-21** | Neck-P3 | 增强小目标融合 | 256通道 |
| **Head-26** | Head-P4 | 增强中等目标检测 | 512通道 |
| **Head-31** | Head-P5 | 增强大目标检测 | 1024通道 |

---

## 🧠 CBAM原理详解

### 一句话总结

> **CBAM = 通道注意力 + 空间注意力**
> 
> 先看哪个特征通道重要，再看图片哪个位置重要

### 第一步：通道注意力（Channel Attention）

```
问题：256个特征通道中，哪些对裂缝检测重要？

┌─────────────────────────────────────┐
│ 输入特征图 [B, 256, 32, 32]          │
│                                     │
│ 每个通道提取不同特征：               │
│ - 通道#15：边缘检测                  │
│ - 通道#32：纹理检测                  │
│ - 通道#128：颜色信息                 │
│ - 通道#200：形状特征                 │
└─────────────────────────────────────┘
         ↓
┌─────────────────────────────────────┐
│ 全局池化（压缩空间信息）             │
│                                     │
│ 平均池化 → [B, 256, 1, 1]            │
│ 最大池化 → [B, 256, 1, 1]            │
│                                     │
│ 得到每个通道的整体重要性             │
└─────────────────────────────────────┘
         ↓
┌─────────────────────────────────────┐
│ MLP压缩（学习通道关系）              │
│                                     │
│ 256 → 16 → 256                      │
│                                     │
│ 压缩后恢复，学习通道间依赖关系       │
└─────────────────────────────────────┘
         ↓
┌─────────────────────────────────────┐
│ sigmoid激活（生成权重）              │
│                                     │
│ 通道权重 [B, 256, 1, 1]             │
│                                     │
│ 通道#15（边缘） → 0.85 ★重要！      │
│ 通道#32（纹理） → 0.78 ★重要！      │
│ 通道#128（颜色） → 0.25 ✗不重要     │
└─────────────────────────────────────┘
         ↓
┌─────────────────────────────────────┐
│ 加权融合                             │
│                                     │
│ 输出 = 输入 × 通道权重               │
│                                     │
│ 边缘通道增强，颜色通道削弱           │
└─────────────────────────────────────┘
```

**通俗理解**：
> 就像调色板的滤镜选择器，保留裂缝检测有用的滤镜（边缘、纹理），削弱没用的滤镜（颜色）

### 第二步：空间注意力（Spatial Attention）

```
问题：32×32的空间网格中，哪个位置有裂缝？

┌─────────────────────────────────────┐
│ 输入：通道加权后的特征               │
│ [B, 256, 32, 32]                    │
└─────────────────────────────────────┘
         ↓
┌─────────────────────────────────────┐
│ 通道池化（压缩通道信息）             │
│                                     │
│ 平均池化 → [B, 1, 32, 32]            │
│ 最大池化 → [B, 1, 32, 32]            │
│                                     │
│ 得到每个空间位置的特征强度           │
└─────────────────────────────────────┘
         ↓
┌─────────────────────────────────────┐
│ 拼接                                 │
│                                     │
│ concat → [B, 2, 32, 32]             │
│                                     │
│ 结合平均和最大信息                   │
└─────────────────────────────────────┘
         ↓
┌─────────────────────────────────────┐
│ 7×7卷积（学习空间关系）              │
│                                     │
│ 卷积 → [B, 1, 32, 32]               │
│                                     │
│ 7×7感受野，捕捉裂缝的长条形特征      │
└─────────────────────────────────────┘
         ↓
┌─────────────────────────────────────┐
│ sigmoid激活（生成空间权重图）        │
│                                     │
│ 空间权重图 [B, 1, 32, 32]           │
│                                     │
│ ┌──────────────────┐               │
│ │ 0.1  0.1  0.1  0.1│               │
│ │ 0.2 [0.9][0.8] 0.2│ ← 裂缝位置！  │
│ │ 0.1 [0.9] 0.1  0.1│               │
│ │ 0.1  0.1  0.1  0.1│               │
│ └──────────────────┘               │
│                                     │
│ 裂缝区域权重高，背景区域权重低       │
└─────────────────────────────────────┘
         ↓
┌─────────────────────────────────────┐
│ 加权融合                             │
│                                     │
│ 输出 = 输入 × 空间权重               │
│                                     │
│ 裂缝区域增强，背景区域削弱           │
└─────────────────────────────────────┘
```

**通俗理解**：
> 就像聚光灯，照亮裂缝区域（权重0.9），暗淡背景区域（权重0.1）

### 完整流程图

```
输入特征图 [B, C, H, W]
         │
         ├─────────────────────┐
         │                     │
         ▼                     ▼
    平均池化              最大池化
    [B,C,1,1]            [B,C,1,1]
         │                     │
         └──→ MLP压缩 ←───────┘
                 │
                 ▼
              sigmoid
                 │
                 ▼
           通道权重 [B,C,1,1]
                 │
                 ▼
            × 输入特征
                 │
┌────────────────┴────────────────┐
│   通道加权后的特征 [B,C,H,W]     │
└────────────────┬────────────────┘
                 │
         ├─────────────────────┐
         │                     │
         ▼                     ▼
    通道平均池化          通道最大池化
    [B,1,H,W]            [B,1,H,W]
         │                     │
         └──→ concat ←───────┘
                 │
                 ▼
            7×7卷积
                 │
                 ▼
              sigmoid
                 │
                 ▼
          空间权重 [B,1,H,W]
                 │
                 ▼
            × 输入特征
                 │
                 ▼
┌────────────────┴────────────────┐
│   CBAM增强特征图 [B,C,H,W]       │
│   （尺寸不变，质量提升）          │
└─────────────────────────────────┘
```

---

## 📊 参数量分析

### 单个CBAM模块参数

```
通道注意力：
  MLP: 256 → 16 → 256
  参数 = 256×16 + 16×256 = 8192

空间注意力：
  7×7卷积: 2 → 1
  参数 = 2×1×7×7 = 98

单个CBAM总参数 = 8192 + 98 = 8290 ≈ 8K
```

### YOLOv8+CBAM总参数

```
原始YOLOv8n: 3.01M
CBAM×8:      8K × 8 = 64K

总参数:      3.01M + 0.064M = 3.08M
```

**参数增加极少（仅2%），但效果显著！**

---

## 💡 为什么CBAM有效？

### 1. 自动特征选择

```
传统CNN：所有特征通道平均对待
CBAM：自动选择重要特征通道

裂缝检测中：
- 边缘特征 ★重要（裂缝有边缘）
- 纹理特征 ★重要（裂缝有纹理）
- 颜色特征 ✗不重要（裂缝颜色不明显）

CBAM会自动增强边缘和纹理特征
```

### 2. 空间聚焦

```
传统CNN：所有空间位置平均对待
CBAM：自动聚焦重要位置

裂缝检测中：
- 裂缝位置 ★重要（需要检测）
- 背景位置 ✗不重要（会误检）

CBAM会自动聚焦裂缝区域
```

### 3. 信息互补

```
通道注意力 + 空间注意力 = 双重增强

通道维度：选择用什么特征看
空间维度：选择看哪个位置

两者结合：用重要特征看重要位置
```

---

## 🎯 效果预期

| 方法 | mAP50 | mAP50-95 | 参数量 | 提升 |
|------|-------|----------|--------|------|
| **YOLOv8n 基准** | 0.570 | 0.378 | 3.01M | - |
| **YOLOv8n + 数据增强** | ~0.60 | ~0.40 | 3.01M | +5% |
| **YOLOv8n + CBAM** | ~0.62 | ~0.42 | 3.08M | +7-10% |
| **YOLOv8n + CBAM + 增强** | ~0.65 | ~0.45 | 3.08M | +12-15% |

---

## 🔧 训练命令

```bash
# 进入目录
cd /home/ubuntu/codebase/yexijia/github_project/tunnel/注意力机制改进

# 激活环境
conda activate co2

# 运行脚本
./run.sh

# 选择选项3：训练YOLOv8+CBAM（修改模型结构）
```

---

**总结：CBAM通过通道和空间双重注意力，让网络聚焦重要特征和重要位置，参数增加极少但效果显著！**