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

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

概述

最近看了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)
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模块

  1. 通道分割:将特征通道分为3部分:
    前1/3:向前时序移位(用下一帧的特征替换当前帧)
    中1/3:向后时序移位(用上一帧的特征替换当前帧)
    后1/3:保持不变
  2. 维度变换:
    输入:(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)

视频序列特征融合模块

  1. 运动分支:对输入的时序差分特征(diff_input)做两次卷积和两次TSM,得到 d2。
    外观分支:对原始输入做两次卷积,得到 r2。
    注意力分支:对外观分支 r2 做 1x1 卷积和 sigmoid,得到注意力权重 g1。
    融合:d2 * g1,得到融合后的 rgb1
  2. 输入:diff_input, raw_input → (BT, C, H, W)
    输出:rgb1 → (B
    T, 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
  1. 注意力掩码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

跨模态特征融合模块

交叉注意力融合

  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)
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
相关推荐
九年义务漏网鲨鱼12 分钟前
【大模型学习 | MINIGPT-4原理】
人工智能·深度学习·学习·语言模型·多模态
Antonio91527 分钟前
【音视频】HLS简介与服务器搭建
运维·服务器·音视频
开发者工具分享29 分钟前
文本音频违规识别工具排行榜(12选)
人工智能·音视频
qqxhb1 小时前
零基础数据结构与算法——第四章:基础算法-排序(上)
java·数据结构·算法·冒泡·插入·选择
开开心心_Every2 小时前
便捷的Office批量转PDF工具
开发语言·人工智能·r语言·pdf·c#·音视频·symfony
FirstFrost --sy3 小时前
数据结构之二叉树
c语言·数据结构·c++·算法·链表·深度优先·广度优先
森焱森3 小时前
垂起固定翼无人机介绍
c语言·单片机·算法·架构·无人机
搂鱼1145144 小时前
(倍增)洛谷 P1613 跑路/P4155 国旗计划
算法
Yingye Zhu(HPXXZYY)4 小时前
Codeforces 2021 C Those Who Are With Us
数据结构·c++·算法
无聊的小坏坏5 小时前
三种方法详解最长回文子串问题
c++·算法·回文串