小男孩做爰网站外贸业务流程

概述

最近看了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# denominatordenominator = 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-7x_diff = torch.cat([torch.zeros((B, C, 1, H, W), device=x.device), x.diff(dim=2)], dim=2) / denominatorx_diff = x_diff / x_diff.view(B, -1).std(dim=1)[:, None, None, None, None]x_diff[torch.isnan(x_diff)] = 0return 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_segmentself.fold_div = fold_divdef forward(self, x):nt, c, h, w = x.size()n_batch = nt // self.n_segmentx = x.view(n_batch, self.n_segment, c, h, w)fold = c // self.fold_divout = torch.zeros_like(x)out[:, :-1, :fold] = x[:, 1:, :fold]  # shift leftout[:, 1:, fold: 2 * fold] = x[:, :-1, fold: 2 * fold]  # shift rightout[:, :, 2 * fold:] = x[:, :, 2 * fold:]  # not shiftreturn 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-attentionrgb = 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 Embeddingtime_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_embeddingsrf = 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 VQ = 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 valuergb_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 VQ = 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 valuerf_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