259 lines
19 KiB
Markdown
259 lines
19 KiB
Markdown
# Mona-layer (Multi-cognitive Visual Adapter) — adapter-based PEFT для зрения
|
||
|
||
> Источники: статья [Yin, Hu, Li, Zhang, Yang — «5%>100%: Breaking Performance Shackles of Full Fine-Tuning on Visual Recognition Tasks», arXiv:2408.08345 (CVPR 2025)](https://arxiv.org/abs/2408.08345); официальная реализация [GitHub Leiyi-Hu/mona](https://github.com/Leiyi-Hu/mona).
|
||
> Все формулы блока и псевдокод ниже выверены по файлу [`swin_transformer_mona.py`](https://raw.githubusercontent.com/Leiyi-Hu/mona/master/Swin-Transformer-Classification/mmcls/models/backbones/swin_transformer_mona.py) (классы `Mona` и `MonaOp`).
|
||
|
||
---
|
||
|
||
## 1. Проблема: full fine-tuning против PEFT
|
||
|
||
Классическая схема переноса — *pre-train & fine-tune*: большой backbone обучается на крупном корпусе (ImageNet-21k, LVD-142M и т.п.), затем **все** его веса дообучаются на целевой задаче. На больших целевых датасетах это работает, но имеет два дефекта на **малых** данных:
|
||
|
||
- **Стоимость.** Для Swin-L это ~198M обучаемых параметров и отдельная полная копия весов на каждую задачу/чекпойнт ([Yin et al., 2024](https://arxiv.org/abs/2408.08345)).
|
||
- **Переобучение.** При малом числе примеров обновление всех параметров подгоняет backbone под шум обучающей выборки; обобщение падает.
|
||
|
||
**PEFT (parameter-efficient fine-tuning, она же delta-tuning)** решает обе проблемы: backbone **заморожен** ($\nabla_\theta = 0$), обучается лишь малая доля новых параметров $\Delta$ (обычно 0.1–5 %). Семейства PEFT:
|
||
|
||
| Семейство | Что обучается | Представитель |
|
||
|-----------|---------------|---------------|
|
||
| Bias-tuning | только bias-векторы | BitFit |
|
||
| Low-rank | низкоранговые добавки $BA$ к линейным слоям | LoRA |
|
||
| Adapter (последовательный) | bottleneck-MLP внутри блока | Houlsby Adapter, AdaptFormer |
|
||
| Prompt-tuning | обучаемые prompt-токены на входе | VPT |
|
||
| Side-tuning | внешняя «боковая» сеть | LST |
|
||
|
||
Главная претензия статьи Mona: до неё **ни один visual delta-tuning не превосходил full fine-tuning на сложных плотных задачах** (detection, segmentation). Mona — первый метод, который это делает на всех протестированных задачах ([arXiv:2408.08345, abstract](https://arxiv.org/abs/2408.08345)).
|
||
|
||
---
|
||
|
||
## 2. Что такое Mona-блок
|
||
|
||
Mona — это **последовательный adapter** (вставляется в residual-ветку трансформерного блока), но с двумя ключевыми отличиями от языковых адаптеров:
|
||
|
||
1. **Multi-cognitive фильтры** — внутри bottleneck стоят не линейные слои, а набор **depth-wise свёрток разных масштабов** (3×3, 5×5, 7×7), которые усредняются. Это даёт «vision-friendly» обработку (локальность, разные рецептивные поля).
|
||
2. **Scaled LayerNorm на входе** — нормализация с **двумя обучаемыми покомпонентными масштабами** $\gamma$ и $\gamma_x$, регулирующая распределение признаков перед визуальными фильтрами.
|
||
|
||
### 2.1. Структура (по реализации)
|
||
|
||
Внутренний модуль `MonaOp` (multi-scale conv-агрегатор), работает на тензоре $z \in \mathbb{R}^{B\times C_b\times H\times W}$ с $C_b = 64$ (bottleneck), все свёртки **depth-wise** (`groups = C_b`):
|
||
|
||
$$
|
||
\mathrm{MonaOp}(z) = z' + \mathrm{Proj}_{1\times1}(z'),\qquad
|
||
z' = \frac{\mathrm{DW}_{3}(z) + \mathrm{DW}_{5}(z) + \mathrm{DW}_{7}(z)}{3} + z
|
||
$$
|
||
|
||
где $\mathrm{DW}_{k}$ — depth-wise conv с ядром $k\times k$ и padding $k//2$, $\mathrm{Proj}_{1\times1}$ — pointwise conv $1\times1$. Обе агрегации обёрнуты в residual.
|
||
|
||
Внешний модуль `Mona` (вход — последовательность токенов $x \in \mathbb{R}^{B\times N\times C}$, $N = H\cdot W$):
|
||
|
||
$$
|
||
\hat{x} = \mathrm{LayerNorm}(x)\odot \gamma + x \odot \gamma_x \qquad\text{(scaled norm, обучаемые } \gamma,\gamma_x\in\mathbb{R}^{C})
|
||
$$
|
||
$$
|
||
u = W_{\text{down}}\,\hat{x} \in \mathbb{R}^{B\times N\times 64}\quad\text{(down-projection, Linear } C\to 64)
|
||
$$
|
||
$$
|
||
u' = \mathrm{MonaOp}\big(\mathrm{reshape}(u)\big)\quad\text{(токены} \to \text{карта } H\times W \to \text{токены)}
|
||
$$
|
||
$$
|
||
y = W_{\text{up}}\,\mathrm{Dropout}\big(\mathrm{GELU}(u')\big)\in\mathbb{R}^{B\times N\times C}\quad\text{(up-projection, Linear } 64\to C)
|
||
$$
|
||
$$
|
||
\boxed{\;\mathrm{Mona}(x) = x + y\;}\quad\text{(внешний residual)}
|
||
$$
|
||
|
||
Инициализация масштабов в коде: $\gamma = 10^{-6}\cdot\mathbf{1}$ (LayerNorm-ветка стартует почти «выключенной»), $\gamma_x = \mathbf{1}$ (тождественный проброс входа). Это делает Mona при инициализации **близкой к identity** — стабильный старт для дообучения.
|
||
|
||
> Замечание по терминологии: «scaled LayerNorm» здесь = `LayerNorm(x)*γ + x*γx`, то есть **выпуклоподобная** смесь нормированного и исходного признака с обучаемыми покомпонентными весами, а не нормировка с фиксированным множителем.
|
||
|
||
---
|
||
|
||
## 3. Куда вставляется и сколько добавляет
|
||
|
||
В Swin-блоке Mona вставляется **дважды на каждый трансформерный блок** — после attention-ветки и после FFN-ветки (см. `SwinTransformerBlock.forward`):
|
||
|
||
```
|
||
shortcut → (W-MSA/SW-MSA) → x = shortcut + drop_path(x)
|
||
x = Mona_1(x, (H,W)) # adapter после attention
|
||
identity = x; x = norm2(x); x = MLP(x)
|
||
x = identity + drop_path(x)
|
||
x = Mona_2(x, (H,W)) # adapter после FFN
|
||
```
|
||
|
||
- **Замороженным остаётся весь backbone** (attention, MLP, patch-merging, embeddings). Обучаются: параметры всех `Mona`-модулей (down/up Linear, 3 depth-wise conv + 1×1 projector, $\gamma$, $\gamma_x$) и task-head/decoder.
|
||
- **Доля обучаемых параметров backbone:** ~**2.56 %** на Swin-L и ~**4.67 %** на Swin-B (см. таблицы §4) ([arXiv:2408.08345, Tables](https://arxiv.org/abs/2408.08345)). Bottleneck фиксирован на 64 каналов, поэтому стоимость adapter не растёт квадратично с $C$.
|
||
|
||
---
|
||
|
||
## 4. Результаты статьи
|
||
|
||
Сравнение проведено на Swin-B/Swin-L (ImageNet-21k pre-train) против full fine-tuning и набора PEFT. Ниже — выверенные числа из [arXiv:2408.08345](https://arxiv.org/html/2408.08345v1).
|
||
|
||
### 4.1. COCO instance segmentation (Cascade Mask R-CNN, Swin-B)
|
||
|
||
| Метод | Обуч. параметры | % | AP$_{box}$ | AP$_{mask}$ |
|
||
|-------|------------------|------|-----------|-------------|
|
||
| Full fine-tuning | 89.14M | 100.0 | 52.40 | 45.10 |
|
||
| Fixed (frozen) | 0M | 0.0 | 48.00 | 41.60 |
|
||
| BitFit | 0.21M | 0.23 | 50.10 | 43.60 |
|
||
| LoRA | 3.06M | 3.43 | 50.40 | 43.90 |
|
||
| Adapter (Houlsby) | 3.19M | 3.58 | 52.10 | 45.00 |
|
||
| AdaptFormer | 1.60M | 1.79 | 51.70 | 44.60 |
|
||
| **Mona** | **4.16M** | **4.67** | **53.40** | **46.00** |
|
||
|
||
### 4.2. ADE20K semantic segmentation (UperNet, Swin-L)
|
||
|
||
| Метод | Обуч. параметры | % | mIoU |
|
||
|-------|------------------|------|------|
|
||
| Full fine-tuning | 198.58M | 100.0 | 51.18 |
|
||
| Fixed | 0M | 0.0 | 46.84 |
|
||
| BitFit | 0.30M | 0.15 | 48.37 |
|
||
| LoRA | 4.57M | 2.31 | 50.34 |
|
||
| Adapter | 4.61M | 2.33 | 50.78 |
|
||
| AdaptFormer | 2.34M | 1.18 | 50.83 |
|
||
| **Mona** | **5.08M** | **2.56** | **51.36** |
|
||
|
||
### 4.3. Pascal VOC detection (RetinaNet, Swin-L) и DOTA oriented (Oriented R-CNN, Swin-B)
|
||
|
||
| Метод | VOC AP$_{box}$ | DOTA mAP |
|
||
|-------|----------------|----------|
|
||
| Full fine-tuning | 83.70 | 78.31 |
|
||
| BitFit | 85.40 | 76.05 |
|
||
| LoRA | 85.40 | 75.91 |
|
||
| Adapter | 86.70 | 78.27 |
|
||
| AdaptFormer | 86.60 | 77.43 |
|
||
| **Mona** | **87.30** | **78.44** |
|
||
|
||
### 4.4. Image classification (Swin-L, усреднение по датасетам)
|
||
|
||
| Метод | Top-1 Acc | Top-5 Acc |
|
||
|-------|-----------|-----------|
|
||
| Full fine-tuning | 92.79 | 98.81 |
|
||
| BitFit | 93.51 | 99.69 |
|
||
| LoRA | 93.47 | 99.69 |
|
||
| Adapter | 93.99 | 99.61 |
|
||
| AdaptFormer | 93.70 | 99.65 |
|
||
| **Mona** | **94.04** | **99.76** |
|
||
|
||
### 4.5. Почему «5 % > 100 % full FT»
|
||
|
||
- На **плотных** задачах (detection, segmentation) full FT — сильный baseline, и линейные PEFT (LoRA, BitFit, AdaptFormer) его **не достают**. Mona обходит full FT на всех задачах: +1.0 AP$_{box}$ / +0.9 AP$_{mask}$ на COCO, +0.18 mIoU на ADE20K, +3.6 AP на VOC.
|
||
- Причина: **conv-фильтры разных масштабов** дают индуктивное смещение, подходящее под изображения (локальность, многомасштабность), которого нет у линейных адаптеров; а **заморозка backbone** регуляризует — на малых данных полная подгонка переобучается, а 5 % параметров «достаточно гибки, но не настолько, чтобы запомнить шум».
|
||
|
||
---
|
||
|
||
## 5. Mona vs LoRA vs обычный Adapter
|
||
|
||
| Критерий | LoRA | Adapter (Houlsby) | **Mona** |
|
||
|----------|------|-------------------|----------|
|
||
| Куда вставляется | добавка $\Delta W = \frac{\alpha}{r}BA$ к линейным слоям (q,v) | bottleneck-MLP внутри блока | bottleneck **с conv** в residual-ветке (после attn и после FFN) |
|
||
| Внутренние операторы | две линейные матрицы $A,B$ | down-Linear → нелинейность → up-Linear | down-Linear → **3× depth-wise conv (3/5/7) + 1×1** → GELU → up-Linear |
|
||
| Учёт пространства | нет (работает потокенно) | нет | **да** (reshape в карту $H\times W$, multi-scale свёртки) |
|
||
| Нормализация входа | нет | обычно нет | **scaled LayerNorm** с обучаемыми $\gamma,\gamma_x$ |
|
||
| Слияние в инференсе | можно слить в веса (zero-cost) | нет (доп. слой) | нет (доп. слой) |
|
||
| Сильная сторона | дёшево, мерджится | универсален | **vision-friendly, превосходит full FT на dense-задачах** |
|
||
| Доля параметров | ~2–3 % | ~2.3–3.6 % | ~2.5–4.7 % |
|
||
|
||
Ключевое отличие: LoRA и Houlsby-Adapter оперируют **только линейными** преобразованиями признаков и не используют 2D-структуру; Mona добавляет **визуальное индуктивное смещение** (multi-scale depth-wise conv) и **adaptive scaled norm**, поэтому выигрывает именно на изображениях.
|
||
|
||
---
|
||
|
||
## 6. Минимальный PyTorch-скелет Mona
|
||
|
||
Рабочий минимум, эквивалентный официальному коду (`bottleneck=64` по умолчанию, как в репозитории; здесь параметризован).
|
||
|
||
```python
|
||
import torch
|
||
import torch.nn as nn
|
||
import torch.nn.functional as F
|
||
|
||
|
||
class MonaOp(nn.Module):
|
||
"""Multi-cognitive conv aggregator: depthwise 3x3/5x5/7x7 + 1x1 projector."""
|
||
def __init__(self, dim: int):
|
||
super().__init__()
|
||
self.conv1 = nn.Conv2d(dim, dim, 3, padding=1, groups=dim) # depthwise 3x3
|
||
self.conv2 = nn.Conv2d(dim, dim, 5, padding=2, groups=dim) # depthwise 5x5
|
||
self.conv3 = nn.Conv2d(dim, dim, 7, padding=3, groups=dim) # depthwise 7x7
|
||
self.projector = nn.Conv2d(dim, dim, 1) # pointwise 1x1
|
||
|
||
def forward(self, x): # x: (B, dim, H, W)
|
||
identity = x
|
||
x = (self.conv1(x) + self.conv2(x) + self.conv3(x)) / 3.0 + identity
|
||
identity = x
|
||
return identity + self.projector(x) # second residual
|
||
|
||
|
||
class Mona(nn.Module):
|
||
"""Multi-cognitive visual adapter (Yin et al., CVPR 2025)."""
|
||
def __init__(self, in_dim: int, bottleneck: int = 64):
|
||
super().__init__()
|
||
self.norm = nn.LayerNorm(in_dim)
|
||
self.gamma = nn.Parameter(torch.ones(in_dim) * 1e-6) # scaled-norm branch
|
||
self.gammax = nn.Parameter(torch.ones(in_dim)) # identity branch
|
||
self.project1 = nn.Linear(in_dim, bottleneck) # down-projection
|
||
self.adapter_conv = MonaOp(bottleneck) # multi-scale conv
|
||
self.nonlinear = F.gelu
|
||
self.dropout = nn.Dropout(0.1)
|
||
self.project2 = nn.Linear(bottleneck, in_dim) # up-projection
|
||
|
||
def forward(self, x, hw_shape): # x: (B, N, C), hw_shape=(H, W)
|
||
identity = x
|
||
x = self.norm(x) * self.gamma + x * self.gammax # scaled LayerNorm
|
||
u = self.project1(x) # (B, N, bottleneck)
|
||
b, n, c = u.shape
|
||
h, w = hw_shape
|
||
u = u.reshape(b, h, w, c).permute(0, 3, 1, 2) # -> (B, c, H, W)
|
||
u = self.adapter_conv(u)
|
||
u = u.permute(0, 2, 3, 1).reshape(b, n, c) # -> (B, N, c)
|
||
u = self.dropout(self.nonlinear(u))
|
||
return identity + self.project2(u) # outer residual
|
||
```
|
||
|
||
Вставка в трансформерный блок (frozen backbone, обучается только Mona):
|
||
|
||
```python
|
||
# внутри SwinBlock.forward после attention и после FFN:
|
||
x = shortcut + drop_path(attn_out)
|
||
x = mona_after_attn(x, (H, W))
|
||
x = x + drop_path(mlp_out)
|
||
x = mona_after_ffn(x, (H, W))
|
||
```
|
||
|
||
---
|
||
|
||
## 7. Применимость к маленькому датасету Naruto Sign на EdgeNeXt
|
||
|
||
Naruto Sign (распознавание ручных «печатей»/жестов) — **малый** датасет, EdgeNeXt — компактный backbone. Здесь Mona особенно уместен:
|
||
|
||
- **Снижение переобучения.** Backbone EdgeNeXt замораживается (предобученные веса сохраняют общие визуальные признаки), обучается лишь ~2.5–5 % параметров — меньше степеней свободы → меньше шансов запомнить шум малой выборки.
|
||
- **Доменная адаптация через conv.** Жесты рук — локальные многомасштабные паттерны (пальцы, контуры). Multi-scale depth-wise свёртки (3/5/7) подстраивают предобученные признаки под этот домен лучше линейных адаптеров.
|
||
- **Дёшево по памяти.** Хранится один frozen backbone + лёгкие Mona-веса; для edge-сценария это критично.
|
||
|
||
> Замечание по совместимости: EdgeNeXt — гибрид conv+SDTA, а не чистый Swin. Mona-блок (`Mona`/`MonaOp`) переносим почти без изменений: ему нужны лишь токенизированные признаки `(B, N, C)` + `(H, W)` для reshape, либо его можно применять прямо к feature-map `(B, C, H, W)`, опустив permute. Точку вставки (после каждой стадии / после SDTA-блоков) выносим в гиперпараметры.
|
||
|
||
### Гиперпараметры для Optuna
|
||
|
||
| Гиперпараметр | Диапазон / варианты поиска | Комментарий |
|
||
|---------------|----------------------------|-------------|
|
||
| `bottleneck` (down-dim) | {16, 32, 64, 96} | меньше → сильнее регуляризация, дешевле |
|
||
| набор ядер conv | {(3), (3,5), (3,5,7), (5,7)} | trade-off рецептивное поле vs параметры |
|
||
| агрегация ветвей | {mean, learnable-weighted sum} | взвешенная сумма даёт ещё ~$k$ обучаемых скаляров |
|
||
| init `gamma` | {1e-6, 1e-4, 1e-2} | насколько «включена» scaled-norm-ветка на старте |
|
||
| init `gammax` | {1.0, 0.5} | сила identity-проброса |
|
||
| dropout в bottleneck | [0.0, 0.3] | регуляризация под малый датасет |
|
||
| стадии вставки | подмножество {stage1..stage4} | в ранние/поздние стадии или только в часть |
|
||
| позиции в блоке | {after-attn, after-ffn, both} | both = как в оригинале |
|
||
| LR для Mona-параметров | log-uniform [1e-4, 5e-3] | adapter-веса часто требуют LR выше backbone |
|
||
| `weight_decay` Mona | log-uniform [1e-5, 1e-2] | — |
|
||
|
||
Эмпирическое правило (из статьи): на малых/плотных задачах лучше вставлять Mona **во все стадии и обе позиции** (after-attn + after-ffn); сокращать набор ядер до (3,5) или bottleneck до 32 имеет смысл, если Optuna показывает переобучение или упор в бюджет параметров.
|
||
|
||
---
|
||
|
||
## Источники
|
||
|
||
- [Yin D., Hu L., Li B., Zhang Y., Yang X. «5%>100%: Breaking Performance Shackles of Full Fine-Tuning on Visual Recognition Tasks». arXiv:2408.08345, 2024 (CVPR 2025)](https://arxiv.org/abs/2408.08345) — [HTML-версия](https://arxiv.org/html/2408.08345v1).
|
||
- [Официальная реализация — GitHub Leiyi-Hu/mona](https://github.com/Leiyi-Hu/mona); исходник блока — [`swin_transformer_mona.py`](https://raw.githubusercontent.com/Leiyi-Hu/mona/master/Swin-Transformer-Classification/mmcls/models/backbones/swin_transformer_mona.py).
|
||
- PEFT-baselines: LoRA ([Hu et al., 2021, arXiv:2106.09685](https://arxiv.org/abs/2106.09685)); Adapter/Houlsby ([Houlsby et al., 2019, arXiv:1902.00751](https://arxiv.org/abs/1902.00751)); AdaptFormer ([Chen et al., 2022, arXiv:2205.13535](https://arxiv.org/abs/2205.13535)); VPT ([Jia et al., 2022, arXiv:2203.12119](https://arxiv.org/abs/2203.12119)); BitFit ([Zaken et al., 2021, arXiv:2106.10199](https://arxiv.org/abs/2106.10199)).
|