视频序列和射频信号多模态融合算法Fusion-Vital解读
概述
最近看了Fusion-Vital的视频-射频(RGB-RF)融合Transformer模型。记录一下,对于实际项目中的多模态数据融合有一定参考价值。原始论文,参考实现源码。
具体来说,Fusion-Vital模型首先将多帧视频RGB图像投影到一个共享的时间差分域中,以有效捕捉微小的生理信号,同时避免全局运动的干扰。
对于RF射频模态,利用多普勒特性,通过短时傅里叶变换(STFT)生成时间-频率图像,作为时间差分域的替代指标。
模型采用并行编码分支,分别处理RGB和RF数据,并引入多级特征融合模块,利用交叉注意力机制在时间差分域中对齐和融合两种模态的特征。
模型整体流程

整个模型有以下模块组成:
- 时序移动模块(TSM)
- RGB通路(运动分支 + 外观分支)
- RF通路(射频分支)
- 注意力机制(Attention)
- 两次跨模态交互块(CrossAttentionModule)
- 池化与Dropout
- 最终MLP输出
输入输出
- 输入:
rgb_input: 形状为 (B, C=3, T, H, W),视频帧序列。
rf_input: 形状为 (B, C=4, T, F),射频信号时频特征。 - 输出:
bvp :形状为 (B, T),这里为脉搏波形。
视频帧时间差分归一化
- 连续的视频帧时间差分归一化处理。
- 维度变换:
输入:(B, C, T, H, W)
输出:(B, C, T, H, W)
python
def diff_normalize_data(x):
"""Calculate discrete difference in video data along the time-axis and nornamize by its standard deviation."""
B, C, T, H, W = x.shape
# denominator
denominator = torch.ones((B, C, T, H, W), dtype=torch.float32, device=x.device)
for j in range(T - 1):
denominator[:, :, j, :, :] = x[:, :, j + 1, :, :] + x[:, :, j, :, :] + 1e-7
x_diff = torch.cat([torch.zeros((B, C, 1, H, W), device=x.device), x.diff(dim=2)], dim=2) / denominator
x_diff = x_diff / x_diff.view(B, -1).std(dim=1)[:, None, None, None, None]
x_diff[torch.isnan(x_diff)] = 0
return x_diff
TSM模块

- 通道分割:将特征通道分为3部分:
前1/3:向前时序移位(用下一帧的特征替换当前帧)
中1/3:向后时序移位(用上一帧的特征替换当前帧)
后1/3:保持不变 - 维度变换:
输入:(B×T, C, H, W)
python
class TSM(nn.Module):
def __init__(self, n_segment=32, fold_div=3):
super(TSM, self).__init__()
self.n_segment = n_segment
self.fold_div = fold_div
def forward(self, x):
nt, c, h, w = x.size()
n_batch = nt // self.n_segment
x = x.view(n_batch, self.n_segment, c, h, w)
fold = c // self.fold_div
out = torch.zeros_like(x)
out[:, :-1, :fold] = x[:, 1:, :fold] # shift left
out[:, 1:, fold: 2 * fold] = x[:, :-1, fold: 2 * fold] # shift right
out[:, :, 2 * fold:] = x[:, :, 2 * fold:] # not shift
return out.view(nt, c, h, w)
视频序列特征融合模块

- 运动分支:对输入的时序差分特征(diff_input)做两次卷积和两次TSM,得到 d2。
外观分支:对原始输入做两次卷积,得到 r2。
注意力分支:对外观分支 r2 做 1x1 卷积和 sigmoid,得到注意力权重 g1。
融合:d2 * g1,得到融合后的 rgb1 - 输入:diff_input, raw_input → (BT, C, H, W)
输出:rgb1 → (BT, nb_filters1=32, H, W)
python
# 第一次和第二次卷积
diff_input = self.TSM_1(diff_input)
d1 = torch.tanh(self.motion_conv1(diff_input))
d1 = self.TSM_2(d1)
d2 = torch.tanh(self.motion_conv2(d1))
r1 = torch.tanh(self.apperance_conv1(raw_input))
r2 = torch.tanh(self.apperance_conv2(r1))
g1 = torch.sigmoid(self.apperance_att_conv1(r2))
g1 = self.attn_mask_1(g1)
rgb1 = d2 * g1 # 第一次输入Fusion Block的rgb1
- 注意力掩码attn_mask的计算:
- 空间求和:
首先沿高度(H)维度求和,保持维度(keepdim=True)
然后沿宽度(W)维度求和,得到每个空间位置的总和 - 归一化处理:
将输入特征图除以其空间总和,实现初步归一化
乘以高度和宽度恢复数值范围
乘以0.5的缩放因子
python
def forward(self, x):
# 计算空间维度的总和 (高度和宽度)
xsum = torch.sum(x, dim=2, keepdim=True) # 沿高度维度(H)求和
xsum = torch.sum(xsum, dim=3, keepdim=True) # 沿宽度维度(W)求和
# 获取输入形状
xshape = tuple(x.size())
# 计算注意力掩码并应用
return x / xsum * xshape[2] * xshape[3] * 0.5
跨模态特征融合模块

交叉注意力融合
- 展平空间/频率维度,视频帧序列维度变为
(B, T, H*W*C)
,射频序列维度(B, T, F*C)
- 加入时间位置编码,时间位置编码由
time_indices = torch.arange(T, device=rgb.device)
然后经过Embedding实现,输出维度不变:(B, T, H*W*C)
和(B, T, F*C)
- Transform1,Q为视频特征,K和V为射频特征:Q为视频特征维度变换得到,维度
(T, B, D=64)
,K为射频特征变换为得到,维度(T, B, D=64)
,这里把T和B的位置进行了变换,因为nn.MultiheadAttention 默认的输入格式是 (seq_len, batch, embed_dim)。经过MultiheadAttention之后变换回视频特征维度,也就是(B, T, H*W*C)
。 - Transform2: Q为射频特征,K和V为视频特征,同上,经过MultiheadAttention之后变换回射频特征维度,也就是
(B, T, F*C)
。
python
def forward(self, rgb, rf):
B, C, T, H, W = rgb.shape
_, _, _, F = rf.shape
# Flatten spatial dimensions to create sequences for cross-attention
rgb = rgb.permute(0, 2, 3, 4, 1).reshape(B, T, -1) # (B, T, H*W*C)
rf = rf.permute(0, 2, 3, 1).reshape(B, T, -1) # (B, T, F*C)
# print(rgb.shape, rf.shape)
# Temporal Embedding
time_indices = torch.arange(T, device=rgb.device)
rgb_time_embeddings = self.rgb_embedding(time_indices).unsqueeze(0) # (1, T, H*W*C)
rf_time_embeddings = self.rf_embedding(time_indices).unsqueeze(0) # (1, T, F*C)
rgb = rgb + rgb_time_embeddings
rf = rf + rf_time_embeddings
# nn.MultiheadAttention 默认的输入格式是 (seq_len, batch, embed_dim),即 (T, B, D)。
rgb, rf = rgb.permute(1, 0, 2), rf.permute(1, 0, 2)
# Transform RGB to Q and RF to K and V
Q = self.rgb_to_q(rgb) # (T, B, D)
K = self.rf_to_k(rf) # (T, B, D)
V = self.rf_to_v(rf) # (T, B, D)
# Apply cross-attention: RGB as query, RF as key and value
rgb_prime, _ = self.attention_rgb_rf(Q, K, V) # (T, B, D)
rgb_prime = self.proj_rgb(rgb_prime) # (T, B, D)
# Reverse the flattening process for RGB'
rgb_prime = rgb_prime.view(T, B, H, W, C).permute(1, 4, 0, 2, 3) # (B, C, T, H, W)
# Transform RF to Q and RGB to K and V
Q = self.rf_to_q(rf) # (T, B, D)
K = self.rgb_to_k(rgb) # (T, B, D)
V = self.rgb_to_v(rgb) # (T, B, D)
# Apply cross-attention: RF as query, RGB as key and value
rf_prime, _ = self.attention_rf_rgb(Q, K, V) # (T, B, D)
rf_prime = self.proj_rf(rf_prime) # (T, B, D)
# Reverse the flattening process for RF'
rf_prime = rf_prime.view(T, B, F, C).permute(1, 3, 0, 2) # (B, C, T, F)
return rgb_prime, rf_prime