视频序列和射频信号多模态融合算法Fusion-Vital解读

视频序列和射频信号多模态融合算法Fusion-Vital解读

• 概述
• • 模型整体流程
  • 视频帧时间差分归一化
  • TSM模块
  • 视频序列特征融合模块
  • 跨模态特征融合模块

概述

最近看了Fusion-Vital的视频-射频（RGB-RF）融合Transformer模型。记录一下，对于实际项目中的多模态数据融合有一定参考价值。原始论文，参考实现源码。

具体来说，Fusion-Vital模型首先将多帧视频RGB图像投影到一个共享的时间差分域中，以有效捕捉微小的生理信号，同时避免全局运动的干扰。

对于RF射频模态，利用多普勒特性，通过短时傅里叶变换（STFT）生成时间-频率图像，作为时间差分域的替代指标。

模型采用并行编码分支，分别处理RGB和RF数据，并引入多级特征融合模块，利用交叉注意力机制在时间差分域中对齐和融合两种模态的特征。

模型整体流程

整个模型有以下模块组成：

1. 时序移动模块（TSM）
2. RGB通路（运动分支 + 外观分支）
3. RF通路（射频分支）
4. 注意力机制（Attention）
5. 两次跨模态交互块（CrossAttentionModule）
6. 池化与Dropout
7. 最终MLP输出

输入输出

1. 输入：
   rgb_input: 形状为 (B, C=3, T, H, W)，视频帧序列。
   rf_input: 形状为 (B, C=4, T, F)，射频信号时频特征。
2. 输出：
   bvp ：形状为 (B, T)，这里为脉搏波形。
   

视频帧时间差分归一化

1. 连续的视频帧时间差分归一化处理。
2. 维度变换：
   输入：(B, C, T, H, W)
   输出：(B, C, T, H, W)

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模块

1. 通道分割：将特征通道分为3部分：
   前1/3：向前时序移位（用下一帧的特征替换当前帧）
   中1/3：向后时序移位（用上一帧的特征替换当前帧）
   后1/3：保持不变
2. 维度变换：
   输入：(B×T, C, H, W)

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)

视频序列特征融合模块

1. 运动分支：对输入的时序差分特征(diff_input)做两次卷积和两次TSM，得到 d2。
   外观分支：对原始输入做两次卷积，得到 r2。
   注意力分支：对外观分支 r2 做 1x1 卷积和 sigmoid，得到注意力权重 g1。
   融合：d2 * g1，得到融合后的 rgb1
2. 输入：diff_input, raw_input → (BT, C, H, W)
   输出：rgb1 → (BT, nb_filters1=32, H, W)

# 第一次和第二次卷积
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

3. 注意力掩码attn_mask的计算：

• 空间求和：
  首先沿高度(H)维度求和，保持维度(keepdim=True)
  然后沿宽度(W)维度求和，得到每个空间位置的总和
• 归一化处理：
  将输入特征图除以其空间总和，实现初步归一化
  乘以高度和宽度恢复数值范围
  乘以0.5的缩放因子

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

跨模态特征融合模块

交叉注意力融合

1. 展平空间/频率维度，视频帧序列维度变为 (B, T, H*W*C)，射频序列维度(B, T, F*C)
2. 加入时间位置编码，时间位置编码由time_indices = torch.arange(T, device=rgb.device)然后经过Embedding实现，输出维度不变：(B, T, H*W*C)和(B, T, F*C)
3. 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)。
4. Transform2: Q为射频特征，K和V为视频特征，同上，经过MultiheadAttention之后变换回射频特征维度，也就是(B, T, F*C)。

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