YOLO26 MixUp增强：跨样本数据混合的策略与应用：讲解MixUp增强的原理及其在YOLO26中的实现和应用

🎬 Clf丶忆笙：个人主页

🔥 个人专栏：《YOLOv26最新专栏》

⛺️ 努力不一定成功，但不努力一定不成功！

文章目录

• • 一、MixUp增强的核心概念与原理
  • • 1.1 MixUp增强的定义与直觉理解
    • 1.2 MixUp的数学公式
    • 1.3 MixUp与相关技术的对比
    • 1.4 MixUp在目标检测中的特殊性
  • 二、YOLO26中MixUp增强的实现
  • • 2.1 MixUp增强的完整代码实现
    • 2.2 MixUp与马赛克增强的组合实现
    • 2.3 MixUp增强的配置参数
  • 三、MixUp增强的理论分析
  • • 3.1 MixUp的正则化效果
    • 3.2 MixUp对损失函数的影响
    • 3.3 MixUp与模型校准
  • 四、MixUp增强的变体与改进
  • • 4.1 AlignMixUp
    • 4.2 RegMixUp
    • 4.3 类别感知MixUp
  • 五、MixUp增强的调优实战
  • • 5.1 Alpha参数的调优
    • 5.2 MixUp概率的调优
    • 5.3 MixUp与训练阶段的配合
  • 六、MixUp增强的实验分析
  • • 6.1 MixUp对模型性能的影响
    • 6.2 MixUp对不同尺度目标的影响
  • 七、MixUp增强的工程实践
  • • 7.1 MixUp在YOLO26配置文件中的设置
    • 7.2 MixUp增强的调试检查清单
    • 7.3 MixUp增强的常见问题
  • 八、总结

一、MixUp增强的核心概念与原理

1.1 MixUp增强的定义与直觉理解

MixUp增强是一种跨样本的数据增强技术，它的核心思想非常简单却异常有效：将两张不同的训练图片按照一定的比例进行像素级混合，同时将它们的标签也按照相同的比例进行混合。用大白话来说，就是把两张图片"叠"在一起，形成一张半透明的混合图片，标签也按同样的比例"混"在一起。

这种做法乍一看似乎很奇怪——混合后的图片看起来像是"鬼影"一样，既不像图A也不像图B，而标签也不再是0或1这样的确定性标签，而是变成了0.3和0.7这样的概率性标签。但正是这种"模糊化"的处理，给模型带来了强大的正则化效果。

让我们用一个简单的例子来理解MixUp。假设我们有一张猫的图片（标签为[1, 0]，表示100%是猫）和一张狗的图片（标签为[0, 1]，表示100%是狗）。MixUp会以一个混合比例

λ

\\lambda

λ（比如0.7）将这两张图片混合：

新图片

=

0.7

×

猫的图片

+

0.3

×

狗的图片

\\text{新图片} = 0.7 \\times \\text{猫的图片} + 0.3 \\times \\text{狗的图片}

新图片=0.7×猫的图片+0.3×狗的图片

新标签

=

0.7

×

[

1

,

0

]

+

0.3

×

[

0

,

1

]

=

[

0.7

,

0.3

]

\\text{新标签} = 0.7 \\times [1, 0] + 0.3 \\times [0, 1] = [0.7, 0.3]

新标签=0.7×[1,0]+0.3×[0,1]=[0.7,0.3]

混合后的图片看起来70%像猫、30%像狗，而标签也相应地变成了[0.7, 0.3]，表示这张图片有70%的概率是猫、30%的概率是狗。模型在训练时不再追求"非此即彼"的确定性判断，而是学习在模糊输入条件下做出概率性的预测。

1.2 MixUp的数学公式

MixUp的数学定义非常简洁。给定两个样本

(

x

i

,

y

i

)

(x_i, y_i)

(xi​,yi​) 和

(

x

j

,

y

j

)

(x_j, y_j)

(xj​,yj​)，MixUp生成的新样本为：

x

~

=

λ

x

i

+

(

1

−

λ

)

x

j

\\tilde{x} = \\lambda x_i + (1 – \\lambda) x_j

x~=λxi​+(1−λ)xj​

y

~

=

λ

y

i

+

(

1

−

λ

)

y

j

\\tilde{y} = \\lambda y_i + (1 – \\lambda) y_j

y~​=λyi​+(1−λ)yj​

其中

λ

\\lambda

λ 是从Beta分布

B

e

t

a

(

α

,

α

)

Beta(\\alpha, \\alpha)

Beta(α,α) 中采样的混合系数：

λ

∼

B

e

t

a

(

α

,

α

)

\\lambda \\sim Beta(\\alpha, \\alpha)

λ∼Beta(α,α)

Beta分布的概率密度函数为：

f

(

λ

;

α

)

=

λ

α

−

1

(

1

−

λ

)

α

−

1

B

(

α

,

α

)

f(\\lambda; \\alpha) = \\frac{\\lambda^{\\alpha-1}(1-\\lambda)^{\\alpha-1}}{B(\\alpha, \\alpha)}

f(λ;α)=B(α,α)λα−1(1−λ)α−1​

其中

B

(

α

,

α

)

B(\\alpha, \\alpha)

B(α,α) 是Beta函数，用作归一化常数。

参数

α

\\alpha

α 控制了混合比例的分布特性：

• 当 $\alpha \to 0$
• 当 $\alpha =1$
• 当 $\alpha \to \infty$

在YOLO26的实践中，

α

\\alpha

α 通常设置为32.0或更大。这个较大的

α

\\alpha

α 值使得

λ

\\lambda

λ 的分布集中在0和1附近，意味着大多数情况下混合比例接近于1:0或0:1，即一张图片占主导地位，另一张图片只占很小的比例。这种"轻度混合"的策略在目标检测中效果更好，因为过度的混合会导致图片内容难以辨认，影响模型学习。

1.3 MixUp与相关技术的对比

MixUp属于数据增强中"样本混合"类技术的一种。让我们将它与相关的技术进行对比：

#mermaid-svg-nJeUpEL4Iqf9ldhb{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-nJeUpEL4Iqf9ldhb .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-nJeUpEL4Iqf9ldhb .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-nJeUpEL4Iqf9ldhb .error-icon{fill:#552222;}#mermaid-svg-nJeUpEL4Iqf9ldhb .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-nJeUpEL4Iqf9ldhb .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-nJeUpEL4Iqf9ldhb .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-nJeUpEL4Iqf9ldhb .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-nJeUpEL4Iqf9ldhb .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-nJeUpEL4Iqf9ldhb .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-nJeUpEL4Iqf9ldhb .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-nJeUpEL4Iqf9ldhb .marker{fill:#333333;stroke:#333333;}#mermaid-svg-nJeUpEL4Iqf9ldhb .marker.cross{stroke:#333333;}#mermaid-svg-nJeUpEL4Iqf9ldhb svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-nJeUpEL4Iqf9ldhb p{margin:0;}#mermaid-svg-nJeUpEL4Iqf9ldhb .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-nJeUpEL4Iqf9ldhb .cluster-label text{fill:#333;}#mermaid-svg-nJeUpEL4Iqf9ldhb .cluster-label span{color:#333;}#mermaid-svg-nJeUpEL4Iqf9ldhb .cluster-label span p{background-color:transparent;}#mermaid-svg-nJeUpEL4Iqf9ldhb .label text,#mermaid-svg-nJeUpEL4Iqf9ldhb span{fill:#333;color:#333;}#mermaid-svg-nJeUpEL4Iqf9ldhb .node rect,#mermaid-svg-nJeUpEL4Iqf9ldhb .node circle,#mermaid-svg-nJeUpEL4Iqf9ldhb .node ellipse,#mermaid-svg-nJeUpEL4Iqf9ldhb .node polygon,#mermaid-svg-nJeUpEL4Iqf9ldhb .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-nJeUpEL4Iqf9ldhb .rough-node .label text,#mermaid-svg-nJeUpEL4Iqf9ldhb .node .label text,#mermaid-svg-nJeUpEL4Iqf9ldhb .image-shape .label,#mermaid-svg-nJeUpEL4Iqf9ldhb .icon-shape .label{text-anchor:middle;}#mermaid-svg-nJeUpEL4Iqf9ldhb .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-nJeUpEL4Iqf9ldhb .rough-node .label,#mermaid-svg-nJeUpEL4Iqf9ldhb .node .label,#mermaid-svg-nJeUpEL4Iqf9ldhb .image-shape .label,#mermaid-svg-nJeUpEL4Iqf9ldhb .icon-shape .label{text-align:center;}#mermaid-svg-nJeUpEL4Iqf9ldhb .node.clickable{cursor:pointer;}#mermaid-svg-nJeUpEL4Iqf9ldhb .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-nJeUpEL4Iqf9ldhb .arrowheadPath{fill:#333333;}#mermaid-svg-nJeUpEL4Iqf9ldhb .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-nJeUpEL4Iqf9ldhb .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-nJeUpEL4Iqf9ldhb .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-nJeUpEL4Iqf9ldhb .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-nJeUpEL4Iqf9ldhb .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-nJeUpEL4Iqf9ldhb .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-nJeUpEL4Iqf9ldhb .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-nJeUpEL4Iqf9ldhb .cluster text{fill:#333;}#mermaid-svg-nJeUpEL4Iqf9ldhb .cluster span{color:#333;}#mermaid-svg-nJeUpEL4Iqf9ldhb div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-nJeUpEL4Iqf9ldhb .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-nJeUpEL4Iqf9ldhb rect.text{fill:none;stroke-width:0;}#mermaid-svg-nJeUpEL4Iqf9ldhb .icon-shape,#mermaid-svg-nJeUpEL4Iqf9ldhb .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-nJeUpEL4Iqf9ldhb .icon-shape p,#mermaid-svg-nJeUpEL4Iqf9ldhb .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-nJeUpEL4Iqf9ldhb .icon-shape .label rect,#mermaid-svg-nJeUpEL4Iqf9ldhb .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-nJeUpEL4Iqf9ldhb .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-nJeUpEL4Iqf9ldhb .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-nJeUpEL4Iqf9ldhb :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

样本混合增强技术

MixUp

CutMix

Cutout

Mosaic

像素级线性混合

区域级裁剪替换

区域级随机擦除

空间级四图拼接

标签按比例混合

标签按面积混合

标签保持不变

标签直接合并

1.4 MixUp在目标检测中的特殊性

MixUp最初是为图像分类任务设计的。在分类任务中，标签是one-hot向量，混合标签的计算非常直接。但在目标检测中，标签更加复杂——每个样本包含不定数量的边界框和类别标签。这使得MixUp在目标检测中的应用面临一些特殊的挑战：

挑战一：边界框的混合。在分类任务中，标签是固定长度的向量，可以直接线性插值。但在检测任务中，两个样本的边界框数量可能不同，无法直接一一对应进行插值。

挑战二：空间对齐问题。MixUp的像素级混合假设两张图片的空间位置是对齐的——图片A的左上角像素与图片B的左上角像素混合。但在目标检测中，两张图片中的物体位置是随机的，这种空间不对齐可能导致混合后的图片中物体边界模糊，增加检测难度。

挑战三：标签分配策略。YOLO26使用基于网格的标签分配策略，每个网格单元负责检测落入其中的目标。MixUp混合后的图片中，目标的边界变得模糊，这可能影响标签分配的准确性。

YOLO26采用的解决方案是：在像素层面进行MixUp混合，但在标签层面直接合并两个样本的所有边界框，而不是按比例插值标签。这种"像素混合+标签合并"的策略在实践中效果更好，因为它保留了原始标签的精确性，同时通过像素混合增加了输入的多样性。

二、YOLO26中MixUp增强的实现

2.1 MixUp增强的完整代码实现

下面是YOLO26中MixUp增强的完整实现代码，包含详细的注释和功能分析：

import cv2
import numpy as np
import random
from typing import List, Tuple, Dict, Optional

class MixUpAugmentation:
"""
YOLO26 MixUp增强类

将两张训练图片按比例进行像素级混合，同时合并两者的标注框。
YOLO26采用"像素混合+标签合并"的策略，而非原始MixUp的
"像素混合+标签插值"策略。

参数:
alpha: Beta分布的参数，控制混合比例的分布
mixup_prob: MixUp增强的执行概率
img_size: 输出图片尺寸
label_mixing_mode: 标签混合模式，'merge'或'interpolate'
"""

def __init__(
self,
alpha: float = 32.0,
mixup_prob: float = 0.15,
img_size: int = 640,
label_mixing_mode: str = 'merge',
):
self.alpha = alpha
self.mixup_prob = mixup_prob
self.img_size = img_size
self.label_mixing_mode = label_mixing_mode

def __call__(
self,
sample1: Dict,
sample2: Dict,
) –> Dict:
"""
执行MixUp增强

参数:
sample1: 第一个样本字典，包含'image', 'bboxes', 'classes'
sample2: 第二个样本字典

返回:
混合后的样本字典
"""
# 根据概率决定是否执行MixUp
if random.random() > self.mixup_prob:
return sample1

# 从Beta分布中采样混合比例
# alpha较大时，lambda集中在0和1附近，混合程度较轻
lam = np.random.beta(self.alpha, self.alpha)

img1 = sample1['image']
img2 = sample2['image']
bboxes1 = sample1['bboxes']
bboxes2 = sample2['bboxes']
classes1 = sample1['classes']
classes2 = sample2['classes']

# 确保两张图片尺寸一致
if img1.shape[:2] != img2.shape[:2]:
img2 = cv2.resize(img2, (img1.shape[1], img1.shape[0]))

# 像素级混合
# 将两张图片按lambda比例进行线性插值
mixed_img = (
lam * img1.astype(np.float32)
+ (1 – lam) * img2.astype(np.float32)
).astype(np.uint8)

# 标签处理
if self.label_mixing_mode == 'merge':
# 合并模式：直接合并两个样本的所有标注框
# 这是YOLO26采用的策略
mixed_bboxes, mixed_classes = self._merge_labels(
bboxes1, classes1,
bboxes2, classes2,
lam,
)
elif self.label_mixing_mode == 'interpolate':
# 插值模式：按比例插值标签（原始MixUp策略）
mixed_bboxes, mixed_classes = self._interpolate_labels(
bboxes1, classes1,
bboxes2, classes2,
lam,
)
else:
raise ValueError(f"不支持的标签混合模式: {self.label_mixing_mode}")

return {
'image': mixed_img,
'bboxes': mixed_bboxes,
'classes': mixed_classes,
}

def _merge_labels(
self,
bboxes1: np.ndarray,
classes1: np.ndarray,
bboxes2: np.ndarray,
classes2: np.ndarray,
lam: float,
) –> Tuple[np.ndarray, np.ndarray]:
"""
合并两个样本的标签

直接将两个样本的所有标注框合并在一起。
对于占主导比例的样本（lambda > 0.5），其标注框
损失权重为lambda；对于次要样本，其标注框损失权重
为(1-lambda)。

参数:
bboxes1: 第一个样本的标注框
classes1: 第一个样本的类别标签
bboxes2: 第二个样本的标注框
classes2: 第二个样本的类别标签
lam: 混合比例

返回:
合并后的(标注框, 类别标签)元组
"""
if len(bboxes1) > 0 and len(bboxes2) > 0:
merged_bboxes = np.concatenate([bboxes1, bboxes2], axis=0)
merged_classes = np.concatenate([classes1, classes2], axis=0)
elif len(bboxes1) > 0:
merged_bboxes = bboxes1
merged_classes = classes1
elif len(bboxes2) > 0:
merged_bboxes = bboxes2
merged_classes = classes2
else:
merged_bboxes = np.zeros((0, 4), dtype=np.float32)
merged_classes = np.zeros((0,), dtype=np.int64)

return merged_bboxes, merged_classes

def _interpolate_labels(
self,
bboxes1: np.ndarray,
classes1: np.ndarray,
bboxes2: np.ndarray,
classes2: np.ndarray,
lam: float,
) –> Tuple[np.ndarray, np.ndarray]:
"""
按比例插值标签（原始MixUp策略）

对于分类任务，标签是one-hot向量，可以直接插值。
对于检测任务，边界框无法直接插值，因此这种模式
主要用于分类头的标签处理。

参数:
bboxes1: 第一个样本的标注框
classes1: 第一个样本的类别标签
bboxes2: 第二个样本的标注框
classes2: 第二个样本的类别标签
lam: 混合比例

返回:
处理后的(标注框, 类别标签)元组
"""
# 检测任务中边界框无法直接插值，采用合并策略
# 但在损失计算时，对两个样本的损失分别乘以lam和(1-lam)
return self._merge_labels(
bboxes1, classes1,
bboxes2, classes2,
lam,
)

2.2 MixUp与马赛克增强的组合实现

在YOLO26中，MixUp增强通常与马赛克增强组合使用。具体流程是：先对四张图片进行马赛克拼接，然后以一定的概率对马赛克图片和另一张随机图片进行MixUp混合。

class MosaicWithMixUp:
"""
马赛克增强与MixUp增强的组合

先执行马赛克拼接，再以一定概率执行MixUp混合。
这是YOLO26标准训练流水线中的增强组合。

参数:
img_size: 输出图片尺寸
mosaic_prob: 马赛克增强概率
mixup_prob: MixUp增强概率（在马赛克之后执行）
mixup_alpha: MixUp的Beta分布参数
border_ratio_range: 马赛克中心点偏移范围
min_area_ratio: 最小面积保留比例
"""

def __init__(
self,
img_size: int = 640,
mosaic_prob: float = 1.0,
mixup_prob: float = 0.15,
mixup_alpha: float = 32.0,
border_ratio_range: Tuple[float, float] = (0.25, 0.75),
min_area_ratio: float = 0.3,
):
self.img_size = img_size
self.mosaic_prob = mosaic_prob
self.mixup_prob = mixup_prob
self.mixup_alpha = mixup_alpha
self.border_ratio_range = border_ratio_range
self.min_area_ratio = min_area_ratio

def _apply_mosaic(self, sample_list: List[Dict]) –> Dict:
"""
执行马赛克拼接

参数:
sample_list: 包含4个样本的列表

返回:
马赛克拼接后的样本
"""
border_ratio_low, border_ratio_high = self.border_ratio_range
xc = int(random.uniform(border_ratio_low, border_ratio_high) * self.img_size)
yc = int(random.uniform(border_ratio_low, border_ratio_high) * self.img_size)

mosaic_img = np.full(
(self.img_size, self.img_size, 3),
fill_value=114,
dtype=np.uint8,
)
mosaic_bboxes = []
mosaic_classes = []

positions = [
(0, 0, xc, yc),
(0, xc, self.img_size, yc),
(yc, 0, xc, self.img_size),
(yc, xc, self.img_size, self.img_size),
]

for idx, sample in enumerate(sample_list):
img = sample['image']
bboxes = sample['bboxes']
classes = sample['classes']

y1, x1, y2, x2 = positions[idx]
target_h = y2 – y1
target_w = x2 – x1

if target_h <= 0 or target_w <= 0:
continue

resized_img = cv2.resize(
img, (target_w, target_h),
interpolation=cv2.INTER_LINEAR,
)
mosaic_img[y1:y2, x1:x2] = resized_img

if len(bboxes) > 0:
orig_h, orig_w = img.shape[:2]
scale_x = target_w / orig_w
scale_y = target_h / orig_h

new_bboxes = bboxes.copy().astype(np.float32)
new_bboxes[:, 0] = new_bboxes[:, 0] * scale_x + x1
new_bboxes[:, 1] = new_bboxes[:, 1] * scale_y + y1
new_bboxes[:, 2] = new_bboxes[:, 2] * scale_x + x1
new_bboxes[:, 3] = new_bboxes[:, 3] * scale_y + y1

new_bboxes[:, 0] = np.clip(new_bboxes[:, 0], 0, self.img_size)
new_bboxes[:, 1] = np.clip(new_bboxes[:, 1], 0, self.img_size)
new_bboxes[:, 2] = np.clip(new_bboxes[:, 2], 0, self.img_size)
new_bboxes[:, 3] = np.clip(new_bboxes[:, 3], 0, self.img_size)

orig_areas = (bboxes[:, 2] – bboxes[:, 0]) * (bboxes[:, 3] – bboxes[:, 1])
new_areas = (new_bboxes[:, 2] – new_bboxes[:, 0]) * (new_bboxes[:, 3] – new_bboxes[:, 1])
orig_areas = np.maximum(orig_areas, 1e-6)
area_ratios = new_areas / orig_areas

valid_mask = area_ratios >= self.min_area_ratio
valid_width = new_bboxes[:, 2] – new_bboxes[:, 0] > 1
valid_height = new_bboxes[:, 3] – new_bboxes[:, 1] > 1
valid_mask = valid_mask & valid_width & valid_height

if valid_mask.any():
mosaic_bboxes.append(new_bboxes[valid_mask])
mosaic_classes.append(classes[valid_mask])

if len(mosaic_bboxes) > 0:
mosaic_bboxes = np.concatenate(mosaic_bboxes, axis=0)
mosaic_classes = np.concatenate(mosaic_classes, axis=0)
else:
mosaic_bboxes = np.zeros((0, 4), dtype=np.float32)
mosaic_classes = np.zeros((0,), dtype=np.int64)

return {
'image': mosaic_img,
'bboxes': mosaic_bboxes,
'classes': mosaic_classes,
}

def _apply_mixup(
self,
mosaic_sample: Dict,
extra_sample: Dict,
) –> Dict:
"""
在马赛克图片上应用MixUp

参数:
mosaic_sample: 马赛克拼接后的样本
extra_sample: 额外的一张图片样本

返回:
MixUp混合后的样本
"""
lam = np.random.beta(self.mixup_alpha, self.mixup_alpha)

img1 = mosaic_sample['image']
img2 = extra_sample['image']

# 将第二张图片resize到相同尺寸
if img2.shape[:2] != img1.shape[:2]:
img2 = cv2.resize(img2, (img1.shape[1], img1.shape[0]))

# 像素级混合
mixed_img = (
lam * img1.astype(np.float32)
+ (1 – lam) * img2.astype(np.float32)
).astype(np.uint8)

# 合并标注框
bboxes1 = mosaic_sample['bboxes']
classes1 = mosaic_sample['classes']
bboxes2 = extra_sample['bboxes']
classes2 = extra_sample['classes']

# 变换第二张图片的标注框坐标
if len(bboxes2) > 0:
orig_h, orig_w = extra_sample['image'].shape[:2]
scale_x = img1.shape[1] / orig_w
scale_y = img1.shape[0] / orig_h
bboxes2_new = bboxes2.copy().astype(np.float32)
bboxes2_new[:, 0] *= scale_x
bboxes2_new[:, 1] *= scale_y
bboxes2_new[:, 2] *= scale_x
bboxes2_new[:, 3] *= scale_y
else:
bboxes2_new = np.zeros((0, 4), dtype=np.float32)

if len(bboxes1) > 0 and len(bboxes2_new) > 0:
merged_bboxes = np.concatenate([bboxes1, bboxes2_new], axis=0)
merged_classes = np.concatenate([classes1, classes2], axis=0)
elif len(bboxes1) > 0:
merged_bboxes = bboxes1
merged_classes = classes1
elif len(bboxes2_new) > 0:
merged_bboxes = bboxes2_new
merged_classes = classes2
else:
merged_bboxes = np.zeros((0, 4), dtype=np.float32)
merged_classes = np.zeros((0,), dtype=np.int64)

return {
'image': mixed_img,
'bboxes': merged_bboxes,
'classes': merged_classes,
}

def __call__(self, sample_list: List[Dict]) –> Dict:
"""
执行马赛克+MixUp组合增强

参数:
sample_list: 包含5个样本的列表
前4个用于马赛克拼接，第5个用于MixUp

返回:
增强后的样本
"""
# 执行马赛克拼接
if random.random() < self.mosaic_prob:
augmented = self._apply_mosaic(sample_list[:4])
else:
augmented = sample_list[0]

# 执行MixUp
if random.random() < self.mixup_prob and len(sample_list) > 4:
augmented = self._apply_mixup(augmented, sample_list[4])

return augmented

2.3 MixUp增强的配置参数

alpha参数的影响：alpha值对MixUp效果的影响非常显著。下表展示了不同alpha值下混合比例

λ

\\lambda

λ 的分布特性：

三、MixUp增强的理论分析

3.1 MixUp的正则化效果

MixUp的核心作用是正则化。它通过以下几种机制防止模型过拟合：

机制一：决策边界平滑化。在没有MixUp的情况下，模型倾向于在训练样本之间建立"硬"决策边界。MixUp通过在训练样本之间插入混合样本，迫使模型学习更平滑的决策边界。这种平滑化减少了模型对训练数据的过拟合，提高了泛化能力。

从数学上看，MixUp等价于在训练数据的邻域内进行数据增强。对于每个训练样本

x

i

x_i

xi​，MixUp在其与另一个样本

x

j

x_j

xj​ 的连线上生成了新的样本。这些新样本构成了训练数据的一个"凸包"扩展，模型在这个扩展后的数据集上训练，自然会对原始数据分布的微小偏移更加鲁棒。

机制二：标签平滑化。原始MixUp将确定性标签（如[1, 0]）转换为概率性标签（如[0.7, 0.3]），这本质上是一种标签平滑（Label Smoothing）。标签平滑的效果是防止模型对训练标签过度自信，提高模型的校准能力。

在YOLO26的"标签合并"策略中，虽然没有直接进行标签插值，但像素级的混合本身就起到了类似的效果——模型看到的输入不再是"纯粹"的某个类别，而是多个类别的混合，这迫使模型学习更鲁棒的特征。

机制三：对抗训练效应。MixUp生成的混合样本可以看作是对原始样本的一种"对抗性"扰动。模型需要在存在这种扰动的情况下正确识别目标，这类似于对抗训练的效果，提高了模型对输入扰动的鲁棒性。

3.2 MixUp对损失函数的影响

在YOLO26的"标签合并"策略中，MixUp对损失计算的影响需要特别处理。假设混合比例为

λ

\\lambda

λ，样本1的损失为

L

1

L_1

L1​，样本2的损失为

L

2

L_2

L2​，则混合后的总损失为：

L

m

i

x

u

p

=

λ

L

1

+

(

1

−

λ

)

L

2

L_{mixup} = \\lambda L_1 + (1 – \\lambda) L_2

Lmixup​=λL1​+(1−λ)L2​

但在YOLO26的实际实现中，通常将两个样本的标注框直接合并，在损失计算时不区分标注框的来源。这种简化处理在实践中效果也不错，因为当

α

\\alpha

α 较大时，

λ

\\lambda

λ 接近1，一个样本占主导地位，另一个样本的贡献很小。

class MixUpLossWeighter:
"""
MixUp损失加权器

根据MixUp的混合比例，对来自不同样本的标注框
分配不同的损失权重。

参数:
alpha: Beta分布参数
"""

def __init__(self, alpha: float = 32.0):
self.alpha = alpha

def compute_loss_weights(
self,
num_bboxes_sample1: int,
num_bboxes_sample2: int,
lam: float,
) –> np.ndarray:
"""
计算每个标注框的损失权重

来自样本1的标注框权重为lambda，
来自样本2的标注框权重为(1-lambda)。

参数:
num_bboxes_sample1: 样本1的标注框数量
num_bboxes_sample2: 样本2的标注框数量
lam: 混合比例

返回:
损失权重数组
"""
weights = np.ones(num_bboxes_sample1 + num_bboxes_sample2, dtype=np.float32)
weights[:num_bboxes_sample1] = lam
weights[num_bboxes_sample1:] = 1 – lam

return weights

3.3 MixUp与模型校准

模型校准（Model Calibration）是指模型的预测概率与实际准确率之间的一致性。一个良好校准的模型，当它以80%的概率预测某个类别时，实际上应该有80%的概率是正确的。

MixUp对模型校准有显著的正面影响。研究表明，使用MixUp训练的模型通常具有更好的校准性能。这是因为MixUp的标签平滑化效果防止了模型对预测过度自信。

校准性能通常使用Expected Calibration Error (ECE)来衡量：

E

C

E

=

∑

b

=

1

B

n

b

N

∣

a

c

c

b

−

c

o

n

f

b

∣

ECE = \\sum_{b=1}^{B} \\frac{n_b}{N} |acc_b – conf_b|

ECE=b=1∑B​Nnb​​∣accb​−confb​∣

其中

B

B

B 是分桶数量，

n

b

n_b

nb​ 是第

b

b

b 个桶中的样本数，

N

N

N 是总样本数，

a

c

c

b

acc_b

accb​ 是第

b

b

b 个桶中的实际准确率，

c

o

n

f

b

conf_b

confb​ 是第

b

b

b 个桶中的平均置信度。

四、MixUp增强的变体与改进

4.1 AlignMixUp

AlignMixUp是MixUp的一个改进版本，它解决了MixUp中空间不对齐的问题。标准MixUp直接在像素级别混合两张图片，但两张图片中的物体位置可能完全不同，导致混合后的图片中物体边界模糊。

AlignMixUp的核心思想是：先对两张图片进行特征级别的对齐，然后再进行混合。具体来说，它使用注意力机制或特征匹配来找到两张图片中语义对应的区域，然后只混合对应的区域。

class AlignMixUp:
"""
AlignMixUp增强类

改进标准MixUp的空间不对齐问题。
通过特征对齐找到两张图片中语义对应的区域，
然后进行有意义的混合。

参数:
alpha: Beta分布参数
mixup_prob: 执行概率
alignment_threshold: 对齐阈值
"""

def __init__(
self,
alpha: float = 32.0,
mixup_prob: float = 0.15,
alignment_threshold: float = 0.5,
):
self.alpha = alpha
self.mixup_prob = mixup_prob
self.alignment_threshold = alignment_threshold

def _compute_spatial_attention(
self,
img: np.ndarray,
) –> np.ndarray:
"""
计算图片的空间注意力图

使用图片的梯度信息生成空间注意力图，
突出显示物体区域。

参数:
img: 输入图片

返回:
空间注意力图，形状(H, W)，值域[0, 1]
"""
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY).astype(np.float32)

# 使用Sobel算子计算梯度
grad_x = cv2.Sobel(gray, cv2.CV_32F, 1, 0, ksize=3)
grad_y = cv2.Sobel(gray, cv2.CV_32F, 0, 1, ksize=3)

# 梯度幅值
gradient_magnitude = np.sqrt(grad_x ** 2 + grad_y ** 2)

# 归一化到[0, 1]
attention = gradient_magnitude / (gradient_magnitude.max() + 1e-6)

# 高斯模糊平滑
attention = cv2.GaussianBlur(attention, (15, 15), 0)

return attention

def __call__(
self,
sample1: Dict,
sample2: Dict,
) –> Dict:
"""
执行AlignMixUp增强

参数:
sample1: 第一个样本
sample2: 第二个样本

返回:
混合后的样本
"""
if random.random() > self.mixup_prob:
return sample1

lam = np.random.beta(self.alpha, self.alpha)

img1 = sample1['image']
img2 = sample2['image']

if img1.shape[:2] != img2.shape[:2]:
img2 = cv2.resize(img2, (img1.shape[1], img1.shape[0]))

# 计算空间注意力图
attention1 = self._compute_spatial_attention(img1)
attention2 = self._compute_spatial_attention(img2)

# 生成对齐的混合权重图
# 在物体区域使用更保守的混合比例，避免破坏物体边界
# 在背景区域使用更激进的混合比例
aligned_weight = np.where(
(attention1 > self.alignment_threshold) | (attention2 > self.alignment_threshold),
lam * 0.9 + 0.05, # 物体区域：混合更轻
lam, # 背景区域：正常混合
)

# 扩展到3通道
aligned_weight = aligned_weight[:, :, np.newaxis]

# 像素级混合（使用对齐的权重）
mixed_img = (
aligned_weight * img1.astype(np.float32)
+ (1 – aligned_weight) * img2.astype(np.float32)
).astype(np.uint8)

# 合并标签
bboxes1 = sample1['bboxes']
classes1 = sample1['classes']
bboxes2 = sample2['bboxes']
classes2 = sample2['classes']

if len(bboxes1) > 0 and len(bboxes2) > 0:
merged_bboxes = np.concatenate([bboxes1, bboxes2], axis=0)
merged_classes = np.concatenate([classes1, classes2], axis=0)
elif len(bboxes1) > 0:
merged_bboxes = bboxes1
merged_classes = classes1
elif len(bboxes2) > 0:
merged_bboxes = bboxes2
merged_classes = classes2
else:
merged_bboxes = np.zeros((0, 4), dtype=np.float32)
merged_classes = np.zeros((0,), dtype=np.int64)

return {
'image': mixed_img,
'bboxes': merged_bboxes,
'classes': merged_classes,
}

4.2 RegMixUp

RegMixUp是另一种MixUp变体，它在损失函数层面进行改进。标准MixUp将混合样本的损失作为额外的训练信号，而RegMixUp将混合样本的损失作为一种正则化项，添加到原始损失之上：

L

t

o

t

a

l

=

L

o

r

i

g

i

n

a

l

+

β

⋅

L

m

i

x

u

p

L_{total} = L_{original} + \\beta \\cdot L_{mixup}

Ltotal​=Loriginal​+β⋅Lmixup​

其中

β

\\beta

β 是正则化系数，控制MixUp正则化的强度。这种设计保留了原始训练信号的完整性，同时通过MixUp损失提供额外的正则化。

class RegMixUpLoss:
"""
RegMixUp损失函数

将MixUp损失作为正则化项添加到原始损失之上。

参数:
base_loss_fn: 基础损失函数
reg_weight: MixUp正则化权重
"""

def __init__(
self,
base_loss_fn,
reg_weight: float = 0.1,
):
self.base_loss_fn = base_loss_fn
self.reg_weight = reg_weight

def compute_loss(
self,
predictions_original,
targets_original,
predictions_mixed,
targets_mixed,
):
"""
计算RegMixUp总损失

参数:
predictions_original: 原始样本的模型预测
targets_original: 原始样本的标签
predictions_mixed: 混合样本的模型预测
targets_mixed: 混合样本的标签

返回:
总损失值
"""
# 原始损失
loss_original = self.base_loss_fn(predictions_original, targets_original)

# MixUp正则化损失
loss_mixup = self.base_loss_fn(predictions_mixed, targets_mixed)

# 总损失
total_loss = loss_original + self.reg_weight * loss_mixup

return total_loss

4.3 类别感知MixUp

类别感知MixUp是一种针对目标检测任务优化的MixUp变体。它的核心思想是：在混合两张图片时，优先选择包含不同类别的图片进行混合，以最大化增强的多样性。

class ClassAwareMixUp:
"""
类别感知MixUp增强

优先选择包含不同类别的图片进行混合，
最大化增强的多样性。

参数:
alpha: Beta分布参数
mixup_prob: 执行概率
diversity_weight: 多样性权重
"""

def __init__(
self,
alpha: float = 32.0,
mixup_prob: float = 0.15,
diversity_weight: float = 1.0,
):
self.alpha = alpha
self.mixup_prob = mixup_prob
self.diversity_weight = diversity_weight

def _compute_class_diversity(
self,
classes1: np.ndarray,
classes2: np.ndarray,
) –> float:
"""
计算两个样本之间的类别多样性分数

两个样本包含的不同类别越多，多样性分数越高。

参数:
classes1: 第一个样本的类别标签
classes2: 第二个样本的类别标签

返回:
多样性分数
"""
set1 = set(classes1.tolist()) if len(classes1) > 0 else set()
set2 = set(classes2.tolist()) if len(classes2) > 0 else set()

# 交集越小、并集越大，多样性越高
intersection = len(set1 & set2)
union = len(set1 | set2)

if union == 0:
return 0.0

# Jaccard距离作为多样性度量
diversity = 1.0 – intersection / union

return diversity

def select_mixup_partner(
self,
anchor_sample: Dict,
candidate_samples: List[Dict],
num_candidates: int = 5,
) –> Dict:
"""
为锚点样本选择最佳的MixUp伙伴

从候选样本中选择与锚点样本类别多样性最高的样本。

参数:
anchor_sample: 锚点样本
candidate_samples: 候选样本列表
num_candidates: 候选数量

返回:
最佳MixUp伙伴样本
"""
if len(candidate_samples) == 0:
return anchor_sample

# 随机选择一部分候选样本
candidates = random.sample(
candidate_samples,
min(num_candidates, len(candidate_samples)),
)

# 计算每个候选的多样性分数
diversity_scores = []
for candidate in candidates:
score = self._compute_class_diversity(
anchor_sample['classes'],
candidate['classes'],
)
diversity_scores.append(score)

# 以多样性分数为概率进行采样
total = sum(diversity_scores) + 1e-6
probs = [s / total for s in diversity_scores]

selected_idx = np.random.choice(len(candidates), p=probs)

return candidates[selected_idx]

五、MixUp增强的调优实战

5.1 Alpha参数的调优

Alpha参数是MixUp增强中最重要的超参数。它控制了混合比例的分布，直接影响增强的效果。以下是不同场景下的alpha调优建议：

5.2 MixUp概率的调优

MixUp概率控制了增强的频率。在YOLO26中，默认值为0.15，即15%的训练样本会应用MixUp。这个概率需要根据具体场景调整：

• 低概率（0.05-0.1）：适合微调或大数据集场景，MixUp只偶尔应用
• 中概率（0.1-0.2）：YOLO26的默认范围，适合大多数场景
• 高概率（0.2-0.5）：适合小数据集或需要强正则化的场景

5.3 MixUp与训练阶段的配合

与马赛克增强类似，MixUp增强也可以在训练后期逐渐关闭。但与马赛克增强不同的是，MixUp的关闭时机通常更晚，因为MixUp的正则化效果在训练后期仍然有益。

class MixUpProbScheduler:
"""
MixUp概率调度器

在训练过程中动态调整MixUp的执行概率。

参数:
initial_prob: 初始概率
final_prob: 最终概率
total_epochs: 总训练轮数
close_epochs: 在最后N个epoch关闭
"""

def __init__(
self,
initial_prob: float = 0.15,
final_prob: float = 0.0,
total_epochs: int = 300,
close_epochs: int = 15,
):
self.initial_prob = initial_prob
self.final_prob = final_prob
self.total_epochs = total_epochs
self.close_epochs = close_epochs

def get_prob(self, current_epoch: int) –> float:
"""获取当前epoch的MixUp概率"""
if current_epoch >= self.total_epochs – self.close_epochs:
return 0.0

effective_total = self.total_epochs – self.close_epochs
progress = current_epoch / effective_total

prob = self.initial_prob + (self.final_prob – self.initial_prob) * progress
return max(0.0, min(1.0, prob))

六、MixUp增强的实验分析

6.1 MixUp对模型性能的影响

以下是在COCO数据集上使用YOLO26-nano模型的实验结果：

从实验结果可以看出：

6.2 MixUp对不同尺度目标的影响

MixUp对小目标有轻微的负面影响，因为像素级混合会模糊小目标的边界。对中等和大目标则有正面影响。

七、MixUp增强的工程实践

7.1 MixUp在YOLO26配置文件中的设置

# YOLO26配置文件中的MixUp相关参数
augmentation:
mosaic: True
mosaic_prob: 1.0
mixup: True
mixup_prob: 0.15
mixup_alpha: 32.0
close_mosaic: 30
close_mixup: 15

7.2 MixUp增强的调试检查清单

7.3 MixUp增强的常见问题

问题1：混合后图片太模糊。这通常是因为alpha值太小，导致混合比例接近0.5。解决方案是增大alpha值。

问题2：小目标检测精度下降。MixUp对小目标有负面影响。解决方案是增大alpha值（使混合更轻），或在包含小目标的样本上降低MixUp概率。

问题3：训练不稳定。MixUp增加了训练的难度，可能导致训练初期不稳定。解决方案是降低MixUp概率或使用warmup策略。

#mermaid-svg-hwVboWZJDgicZsGx{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-svg-hwVboWZJDgicZsGx .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-svg-hwVboWZJDgicZsGx .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-svg-hwVboWZJDgicZsGx .error-icon{fill:#552222;}#mermaid-svg-hwVboWZJDgicZsGx .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-hwVboWZJDgicZsGx .edge-thickness-normal{stroke-width:1px;}#mermaid-svg-hwVboWZJDgicZsGx .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-hwVboWZJDgicZsGx .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-hwVboWZJDgicZsGx .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-svg-hwVboWZJDgicZsGx .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-hwVboWZJDgicZsGx .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-hwVboWZJDgicZsGx .marker{fill:#333333;stroke:#333333;}#mermaid-svg-hwVboWZJDgicZsGx .marker.cross{stroke:#333333;}#mermaid-svg-hwVboWZJDgicZsGx svg{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-hwVboWZJDgicZsGx p{margin:0;}#mermaid-svg-hwVboWZJDgicZsGx .label{font-family:\”trebuchet ms\”,verdana,arial,sans-serif;color:#333;}#mermaid-svg-hwVboWZJDgicZsGx .cluster-label text{fill:#333;}#mermaid-svg-hwVboWZJDgicZsGx .cluster-label span{color:#333;}#mermaid-svg-hwVboWZJDgicZsGx .cluster-label span p{background-color:transparent;}#mermaid-svg-hwVboWZJDgicZsGx .label text,#mermaid-svg-hwVboWZJDgicZsGx span{fill:#333;color:#333;}#mermaid-svg-hwVboWZJDgicZsGx .node rect,#mermaid-svg-hwVboWZJDgicZsGx .node circle,#mermaid-svg-hwVboWZJDgicZsGx .node ellipse,#mermaid-svg-hwVboWZJDgicZsGx .node polygon,#mermaid-svg-hwVboWZJDgicZsGx .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-hwVboWZJDgicZsGx .rough-node .label text,#mermaid-svg-hwVboWZJDgicZsGx .node .label text,#mermaid-svg-hwVboWZJDgicZsGx .image-shape .label,#mermaid-svg-hwVboWZJDgicZsGx .icon-shape .label{text-anchor:middle;}#mermaid-svg-hwVboWZJDgicZsGx .node .katex path{fill:#000;stroke:#000;stroke-width:1px;}#mermaid-svg-hwVboWZJDgicZsGx .rough-node .label,#mermaid-svg-hwVboWZJDgicZsGx .node .label,#mermaid-svg-hwVboWZJDgicZsGx .image-shape .label,#mermaid-svg-hwVboWZJDgicZsGx .icon-shape .label{text-align:center;}#mermaid-svg-hwVboWZJDgicZsGx .node.clickable{cursor:pointer;}#mermaid-svg-hwVboWZJDgicZsGx .root .anchor path{fill:#333333!important;stroke-width:0;stroke:#333333;}#mermaid-svg-hwVboWZJDgicZsGx .arrowheadPath{fill:#333333;}#mermaid-svg-hwVboWZJDgicZsGx .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-hwVboWZJDgicZsGx .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-hwVboWZJDgicZsGx .edgeLabel{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-hwVboWZJDgicZsGx .edgeLabel p{background-color:rgba(232,232,232, 0.8);}#mermaid-svg-hwVboWZJDgicZsGx .edgeLabel rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-hwVboWZJDgicZsGx .labelBkg{background-color:rgba(232, 232, 232, 0.5);}#mermaid-svg-hwVboWZJDgicZsGx .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-hwVboWZJDgicZsGx .cluster text{fill:#333;}#mermaid-svg-hwVboWZJDgicZsGx .cluster span{color:#333;}#mermaid-svg-hwVboWZJDgicZsGx div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\”trebuchet ms\”,verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-hwVboWZJDgicZsGx .flowchartTitleText{text-anchor:middle;font-size:18px;fill:#333;}#mermaid-svg-hwVboWZJDgicZsGx rect.text{fill:none;stroke-width:0;}#mermaid-svg-hwVboWZJDgicZsGx .icon-shape,#mermaid-svg-hwVboWZJDgicZsGx .image-shape{background-color:rgba(232,232,232, 0.8);text-align:center;}#mermaid-svg-hwVboWZJDgicZsGx .icon-shape p,#mermaid-svg-hwVboWZJDgicZsGx .image-shape p{background-color:rgba(232,232,232, 0.8);padding:2px;}#mermaid-svg-hwVboWZJDgicZsGx .icon-shape .label rect,#mermaid-svg-hwVboWZJDgicZsGx .image-shape .label rect{opacity:0.5;background-color:rgba(232,232,232, 0.8);fill:rgba(232,232,232, 0.8);}#mermaid-svg-hwVboWZJDgicZsGx .label-icon{display:inline-block;height:1em;overflow:visible;vertical-align:-0.125em;}#mermaid-svg-hwVboWZJDgicZsGx .node .label-icon path{fill:currentColor;stroke:revert;stroke-width:revert;}#mermaid-svg-hwVboWZJDgicZsGx :root{–mermaid-font-family:\”trebuchet ms\”,verdana,arial,sans-serif;}

小

中

大

小目标为主

大目标为主

是

否

开始使用MixUp

数据集大小?

alpha=8-16, prob=0.2

alpha=32, prob=0.15

alpha=32-64, prob=0.1

目标大小?

增大alpha到64+

使用默认alpha=32

训练并评估

mAP是否提升?

保留MixUp配置

降低prob或关闭MixUp

八、总结

MixUp增强作为一种跨样本数据混合技术，在YOLO26中发挥着重要的正则化作用。通过与马赛克增强的组合使用，MixUp可以进一步提升模型的泛化能力和检测精度。

核心要点回顾：