多模态AttnMask总结

最新推荐文章于 2025-06-11 21:15:23 发布
最新推荐文章于 2025-06-11 21:15:23 发布
阅读量873 收藏 28
点赞数 16
文章标签： 深度学习 pytorch 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_54338498/article/details/146978199
版权

设计Attention Mask限定注意力范围的初衷主要有2个：

  1. Sparse Attention减少计算量，每个token只能看到附近的token等。
  2. 缓解训练和推理不一致，尤其是自回归的训练中，需要先生成前面的token，再生成后面的token。

纵坐标为query，横坐标为key，黄色部分表示每个query能看到哪几个key（即query要和哪些key算注意力权重）。
在这里插入图片描述

attn_weight矩阵本质上会告诉你每个 token 之间的相互作用强度，值汇总来自所有其他 token 的每个 token 的信息。例如Causal Mask理想情况下希望从矩阵的上三角中删除所有值。实现时并不是删除，而是用 -inf 替换它。这是因为当应用 softmax 时，这些极小的值将变为零，因此不会产生任何影响。attn_mask在q@k之后，softmax之前使用：

# Efficient implementation equivalent to the following:
def scaled_dot_product_attention(query, key, value, attn_mask=None, dropout_p=0.0, scale=None) -> torch.Tensor:
    L, S = query.size(-2), key.size(-2)
    scale_factor = 1 / math.sqrt(query.size(-1)) if scale is None else scale
    
    attn_bias = torch.zeros(L, S, dtype=query.dtype, device=query.device)
    if attn_mask is not None:
        if attn_mask.dtype == torch.bool:
            attn_bias.masked_fill_(attn_mask.logical_not(), float("-inf"))
        else:
            attn_bias = attn_mask + attn_bias
            
    attn_weight = query @ key.transpose(-2, -1) * scale_factor
    attn_weight += attn_bias  # add attn bias as mask
    attn_weight = torch.softmax(attn_weight, dim=-1)
    attn_weight = torch.dropout(attn_weight, dropout_p, train=True)
    return attn_weight @ value

Pre-train Mask

文本因果掩码（Text Causal Mask）

生成当前 token 时，只能看到自己和之前的 token。tril 返回输入矩阵的主对角线以下的下三角矩阵，其它元素全部置为0。

  • 作用：LLM文本自回归，逐token生成。预训练文本生成任务。
import torch
import matplotlib.pyplot as plt

N = 16  # 序列长度
attn_mask = torch.tril(torch.ones(N, N))
print(attn_mask)

plt.figure(figsize=(4, 4))
plt.imshow(attn_mask.numpy(), cmap='Blues')
plt.title("Causal Mask: Yellow is True, Purple is False")
plt.axis('off')
plt.savefig('causal_mask.png')
plt.show()

在这里插入图片描述

tensor([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]])

图生文掩码（I2T Mask）

image token可以看到彼此，后面生成的token是只能看到前面的所有token。

  • 作用：预训练image caption任务。
    import torch
    import matplotlib.pyplot as plt

    # 参数设置
    N_image = 4  # 图像 token 的数量
    N_text = 12   # 文本 token 的数量
    N = N_image + N_text  # 总序列长度

    # 创建 i2t mask
    i2t_mask = torch.zeros(N, N)

    # 图像 token 可以相互看到
    i2t_mask[:N_image, :N_image] = 1

    # 文本 token 可以看到所有图像 token 和前面的文本 token（因果掩码）
    text_mask = torch.tril(torch.ones(N_text, N_text))
    i2t_mask[N_image:, :N_image] = 1  # 文本 token 可以看到所有图像 token
    i2t_mask[N_image:, N_image:] = text_mask  # 文本 token 是因果的

    # 可视化
    plt.figure(figsize=(4, 4))
    plt.imshow(i2t_mask.numpy())
    plt.title("Image tokens see each other,\n text tokens are causal")
    plt.axis('off')
    plt.savefig('i2t_mask.png')
    plt.show()

在这里插入图片描述

tensor([[1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]])

文生图掩码（T2I Mask）

文本 token因果生成，每个文本 token 只能看到前面的文本 token。图像 token可以相互看到，不受因果限制。

  • 作用：预训练文生图任务。
    import torch
    import matplotlib.pyplot as plt

    # 参数设置
    N_text = 12  # 文本 token 的数量
    N_image = 4  # 图像 token 的数量
    N = N_text + N_image  # 总序列长度

    # 创建文生图掩码
    t2i_mask = torch.zeros(N, N)

    # 文本 token 是因果的
    text_mask = torch.tril(torch.ones(N_text, N_text))
    t2i_mask[:N_text, :N_text] = text_mask  # 文本 token 是因果的

    # 图像 token 可以相互看到
    image_mask = torch.ones(N_image, N_image)
    t2i_mask[N_text:, N_text:] = image_mask  # 图像 token 可以相互看到

    # 图像 token 可以看到所有文本 token
    t2i_mask[N_text:, :N_text] = 1  # 图像 token 可以看到所有文本 token
    print(t2i_mask)

    # 可视化
    plt.figure(figsize=(6, 6))
    plt.imshow(t2i_mask.numpy())
    plt.title("T2I Mask: Text tokens are causal,\n Image tokens see each other")
    plt.axis('off')
    plt.savefig('t2i_mask.png')
    plt.show()

在这里插入图片描述

tensor([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]])

视频帧因果掩码（Video Frame Causal Mask）

因果块掩码结合了因果掩码和块掩码的特性。每个块内部的 token 可以相互看见，后面块的 token 可以看到前面所有块的 token。

  • 作用：视频帧自回归生成预训练，当前帧的token可以看到前面所有帧的token。
    import torch
    import matplotlib.pyplot as plt

    N = 16  # 序列长度
    block_size = 4  # 每个块的大小
    num_blocks = N // block_size

    # 创建因果掩码
    causal_mask = torch.tril(torch.ones(N, N))

    # 创建块掩码
    block_mask = torch.block_diag(*[torch.ones(block_size, block_size)] * num_blocks)

    # 结合因果掩码和块掩码
    causal_block_mask = (causal_mask + block_mask) > 0.5
    causal_block_mask = causal_block_mask.to(torch.float)
    print(causal_block_mask)

    plt.figure(figsize=(4, 4))
    plt.imshow(causal_block_mask.numpy())
    plt.title("Causal Block Mask: Yellow is True, Purple is False")
    plt.axis('off')
    plt.savefig('causal_block_mask.png')
    plt.show()

在这里插入图片描述

tensor([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 1., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 1., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 1., 1.]])

视频生文掩码（V2T Mask）

序列中先video token后text token。视频帧内token可以相互看见，当前视频帧token可以看到前面所有帧的token，生成的文本token可以看到前面所有帧的token和前面生成的text token。

  • 作用：预训练video caption任务。
    import torch
    import matplotlib.pyplot as plt

    # 参数设置
    N_frame = 4  # 视频帧的数量
    N_video_per_frame = 4  # 每个帧内的视频 token 数量
    N_text = 8  # 文本 token 的数量
    N_video = N_frame * N_video_per_frame  # 总视频 token 数量
    N = N_video + N_text  # 总序列长度

    # 创建视频生文掩码
    v2t_mask = torch.zeros(N, N)

    # 视频帧内的 token 可以相互看见
    for i in range(N_frame):
        start = i * N_video_per_frame
        end = start + N_video_per_frame
        v2t_mask[start:end, start:end] = 1  # 当前帧内的 token 可以相互看见

    # 当前视频帧的 token 可以看到前面所有帧的 token
    for i in range(1, N_frame):
        start = i * N_video_per_frame
        end = start + N_video_per_frame
        v2t_mask[start:end, :start] = 1  # 当前帧的 token 可以看到前面所有帧的 token

    # 文本 token 可以看到前面所有帧的 token 和前面生成的文本 token
    text_mask = torch.tril(torch.ones(N_text, N_text))
    v2t_mask[N_video:, :N_video] = 1  # 文本 token 可以看到前面所有帧的 token
    v2t_mask[N_video:, N_video:] = text_mask  # 文本 token 是因果的

    print(v2t_mask)
    # 可视化
    plt.figure(figsize=(6, 6))
    plt.imshow(v2t_mask.numpy())
    plt.title("V2T Mask: Video tokens see each other,\n Text tokens are causal")
    plt.axis('off')
    plt.savefig('v2t_mask.png')
    plt.show()

在这里插入图片描述

tensor([[1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
         1., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
         1., 1., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
         1., 1., 1., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
         1., 1., 1., 1., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
         1., 1., 1., 1., 1., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
         1., 1., 1., 1., 1., 1.]])

文生视频掩码（T2V Mask）

序列中先text token后video token。生成的文本token可以看到前面生成的text token。视频帧内token可以相互看见，当前视频帧token可以看到前面的文本token以及前面生成的所有帧的token。

  • 作用：预训练文生图任务。
    import torch
    import matplotlib.pyplot as plt

    # 参数设置
    N_frame = 4  # 视频帧的数量
    N_video_per_frame = 4  # 每个帧内的视频 token 数量
    N_text = 8  # 文本 token 的数量
    N_video = N_frame * N_video_per_frame  # 总视频 token 数量
    N = N_text + N_video  # 总序列长度

    # 创建文生视频掩码
    t2v_mask = torch.zeros(N, N)

    # 文本 token 是因果的
    text_mask = torch.tril(torch.ones(N_text, N_text))
    t2v_mask[:N_text, :N_text] = text_mask  # 文本 token 是因果的

    # 视频帧内的 token 可以相互看见
    for i in range(N_frame):
        start = N_text + i * N_video_per_frame
        end = start + N_video_per_frame
        t2v_mask[start:end, start:end] = 1  # 当前帧内的 token 可以相互看见

    # 当前视频帧的 token 可以看到前面的文本 token 以及前面生成的所有帧的 token
    for i in range(0, N_frame):
        start = N_text + i * N_video_per_frame
        end = start + N_video_per_frame
        t2v_mask[start:end, :start] = 1  # 当前帧的 token 可以看到前面的文本 token 和前面所有帧的 token

    print(t2v_mask)
    # 可视化
    plt.figure(figsize=(6, 6))
    plt.imshow(t2v_mask.numpy())
    plt.title("T2V Mask: Text tokens are causal,\n Video tokens see each other")
    plt.axis('off')
    plt.savefig('t2v_mask.png')
    plt.show()

在这里插入图片描述

SFT 前缀掩码（SFT Prefix Mask）

所有的多模态提示信息（image/video/text instruction）都是Prefix，前缀token可以看到彼此，后面生成的token是只能看到前面的所有token。

    import torch
    import matplotlib.pyplot as plt

    # 参数设置
    N_prefix = 8  # 前缀 token 的数量
    N_text1 = 8   # 第一部分文本 token 的数量
    N_image = 4   # 图像 token 的数量
    N_text2 = 8   # 第二部分文本 token 的数量
    N_frame = 4   # 视频帧的数量
    N_video_per_frame = 4  # 每帧的视频 token 数量
    N_video = N_frame * N_video_per_frame  # 总视频 token 数量
    N = N_prefix + N_text1 + N_image + N_text2 + N_video  # 总序列长度

    # 创建 SFT 前缀掩码
    sft_mask = torch.zeros(N, N)

    # 前缀 token 可以看到彼此
    sft_mask[:N_prefix, :N_prefix] = 1

    # 第一部分文本 token 是因果的，可以看到前面的前缀 token
    text1_mask = torch.tril(torch.ones(N_text1, N_text1))
    sft_mask[N_prefix:N_prefix+N_text1, :N_prefix] = 1
    sft_mask[N_prefix:N_prefix+N_text1, N_prefix:N_prefix+N_text1] = text1_mask

    # 图像 token 可以看到前面的所有 token，并且图像 token 之间可以看到彼此
    sft_mask[N_prefix+N_text1:N_prefix+N_text1+N_image, :N_prefix+N_text1] = 1
    sft_mask[N_prefix+N_text1:N_prefix+N_text1+N_image, N_prefix+N_text1:N_prefix+N_text1+N_image] = 1

    # 第二部分文本 token 是因果的，可以看到前面的所有 token
    text2_mask = torch.tril(torch.ones(N_text2, N_text2))
    sft_mask[N_prefix+N_text1+N_image:N_prefix+N_text1+N_image+N_text2, :N_prefix+N_text1+N_image] = 1
    sft_mask[N_prefix+N_text1+N_image:N_prefix+N_text1+N_image+N_text2, N_prefix+N_text1+N_image:N_prefix+N_text1+N_image+N_text2] = text2_mask

    # 视频 token 采用视频因果掩码
    for i in range(N_frame):
        start = N_prefix + N_text1 + N_image + N_text2 + i * N_video_per_frame
        end = start + N_video_per_frame
        # 当前帧的 token 可以看到前面的所有 token
        sft_mask[start:end, :start] = 1
        # 当前帧内的 token 可以相互看见
        sft_mask[start:end, start:end] = 1

    # 可视化
    plt.figure(figsize=(10, 10))
    plt.imshow(sft_mask.numpy())
    plt.title("SFT Prefix Mask: Prefix tokens see each other,\n Generated tokens are causal")
    plt.axis('off')
    plt.savefig('sft_prefix_mask.png')
    plt.show()

支持多模态输出：序列中，前缀token 8个，接着是8个text token（因果生成），可以看到前面全部token；然后是4个image token，不仅image token之间可以看到彼此，而且可以看到前面全部token；然后又是8个text token（因果生成），可以看到前面全部token；最后是4帧每帧4个的video token，采用视频因果掩码。
在这里插入图片描述

tensor([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0.,
         0., 0., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
         1., 1., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
         1., 1., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
         1., 1., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
         1., 1., 0., 0., 0., 0.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
         1., 1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
         1., 1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
         1., 1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
         1., 1., 1., 1., 1., 1.]])
【AI视野·今日CV 计算机视觉论文速览 第272期】Fri, 20 Oct 2023
TomRen
10-24 1047
AI视野·今日CS.CV 计算机视觉论文速览 Fri, 20 Oct 2023 Totally 62 papers 👉上期速览✈更多精彩请移步主页 Daily Computer Vision Papers Putting the Object Back into Video Object Segmentation Authors Ho Kei Cheng, Seoung Wug Oh, Brian Price, Joon Young Lee, Alexander Schwing我们提出了 Cu
RNN和CNN使用场景区别
mayaohao的博客
06-06 1069
RNN（循环神经网络）和 CNN（卷积神经网络）是深度学习中两种核心架构，它们的使用场景主要取决于数据结构和任务需求。
山东大学深度学习2025年期末考试
c335000的博客
06-05 614
1.反向传播2.激活函数3.梯度裁剪4.数据增强5.迁移学习6.过拟合7.word2Vec8.注意力机制。
卷积神经网络（一）
qq_52889317的博客
06-11 612
本章介绍了卷积神经网络(CNN)的基本结构和原理。与全连接网络不同，CNN通过卷积层和池化层处理具有空间结构的图像数据，能够保留输入的形状信息。具体讲解了卷积运算的实现过程，包括滤波器滑动窗口的乘积累加操作和偏置的添加。CNN的典型结构由"卷积-ReLU-(池化)"层组合构成，最后使用"全连接-Softmax"输出结果。该网络结构在图像识别等领域表现出色。
PCDF (Progressive Continuous Discrimination Filter)模块构建
不断积累不断学习
06-07 587
（1）高层特征 → 双线性上采样 → 与低层特征逐级融合。：浅层特征（边缘细节）与深层特征（语义信息）的融合。（3）防止信息退化：跳层连接 + 跨尺度拼接。轻量 MLP：CCM 的通道缩减比1/4。（1）使用深度可分离卷积替代标准卷积。：目标尺寸在视频序列中的剧烈变化。：移除通道响应<0.1的特征层。：低质量医疗图像中的伪影干扰。：融合多尺度上下文信息。：动态调整特征响应权重。通道压缩：CSF 中。（2）保留原始分辨率。U-net++网络中。
【深度学习】深度学习中的张量：从多维数组到智能计算单元
m0_56800366的博客
06-11 359
项目内容张量定义通用的n维数组与NumPy区别支持GPU & 自动微分关键能力高效计算 + 梯度追踪应用场景模型输入/输出/参数的基础单位。
从代码学习深度学习 - 全局向量的词嵌入（GloVe）PyTorch版
weixin_43887510的博客
06-11 501
在自然语言处理（NLP）的广阔天地中，如何让计算机理解人类语言的丰富内涵，一直是核心挑战。词嵌入（Word Embedding）技术为此提供了优雅的解决方案，它将词语映射到低维、稠密的向量空间中，使得语义相近的词在空间中的距离也相近。我们之前已经熟悉了像Word2Vec这样的模型，它通过局部上下文窗口来学习词向量。然而，Word2Vec的视野有限，它一次只能看到一个小的上下文窗口，忽略了语料库中丰富的全局统计信息。今天，我们将深入探讨另一种强大的词嵌入模型——。
RNN做中文分词
mayaohao的博客
06-10 728
结合 RNN 的输出和 CRF 的转移矩阵，使用维特比算法（Viterbi Algorithm）找到最优标签序列。中文与英文不同，词与词之间没有空格分隔。分词就是要在连续的字符流中找出正确的词边界。在中文分词中，每个字符的标签不仅取决于自身，还与前后文相关。RNN 直接预测每个字符的标签时，会忽略标签之间的约束关系（如。普通 RNN 只能看到左侧上下文（从左到右），而中文分词需要。依次处理序列中的每个元素，并维护一个。循环神经网络（RNN）的核心优势是。是标签数量，如 4），其中。最常用的分词标注方案是。
# PyTorch：深度学习世界的真实体验（从零到英雄之旅！）
qq_21422587的博客
06-11 471
回望我的深度学习路，PyTorch像一盏灯——照亮了那些熬夜调试的夜晚（夸张但真）。它的直观、动态本质，让创新不再是天才专利——普通码农也能玩转AI！！！（激动拍桌）别再观望了——装好PyTorch，跑个小例子——你会发现：深度学习，没那么遥不可及。记住，框架只是工具——真正魔力在你的好奇心。冲吧小伙伴们——我在坑里等你们交流心得！（哈哈）
自己编写一个神经网络模型识别数字验证码（卷积神经网络的 Hello world）
univerbright的博客
06-06 1387
开篇之前说明一下：本文纯粹是技术交流和探讨，所用数据为非公开数据集，仅限于学习，不可用以商业和其他用途。实现数字验证码识别目标的整体思路是：(1)-->(2)（为了简单，将每张验证码图像中的4个数字切割开来，形成每张图只有1个数字的训练集，并且文件名的第一个字符为训练图的数字，即标签。）-->(3)数据处理方法、模型、训练方法、测试方法-->(4)和保存模型->。本例准备了1143张验证码图像，切割成4572张单个数字的训练图像。
【GPT模型训练】第二课：张量与秩：从数学本质到深度学习的基础概念解析
spark_dev的博客
06-08 395
在数学和物理学中，张量是一种多维数组，用于表示物理量或几何实体在不同坐标系下的变换关系。在机器学习和深度学习中，张量是数据的基本表示形式，类似于多维数组或矩阵的扩展。张量：多维数组，用于表示数据或物理量。张量的秩：张量的维度数，即需要多少个索引来定位元素。拼音：秩（zhì）。理解张量和秩的概念是学习深度学习和线性代数的基础！
深度学习与食品图像分类数据集（猫脸码客第246期）
猫脸码客的博客
06-10 782
随着深度学习技术的蓬勃发展，图像分类任务在众多领域均取得了令人瞩目的进展。食品图像分类作为其中的一个关键分支，不仅具备显著的实际应用价值，更能激发人们对深度学习技术的浓厚兴趣与深入探索。
手动给中文分词和 直接用神经网络RNN做有什么区别
mayaohao的博客
06-08 587
你的代码使用 RNN 实现分词，正是利用了神经网络在上下文建模和自动特征提取上的优势，尤其适合处理未登录词和复杂语义场景。而神经网络分词更适合。
transformer和 RNN以及他的几个变体区别 改进
mayaohao的博客
06-06 1120
Transformer、RNN 及其变体（LSTM/GRU）是深度学习中处理序列数据的核心模型，但它们的架构设计和应用场景有显著差异。以下从技术原理、优缺点和适用场景三个维度进行对比分析：plaintext （其中 σ 为 sigmoid 函数，⊙为逐元素乘法） GRU：将遗忘门和输入门合并为更新门，减少参数约 30%，计算效率更高。 2. LSTM/GRU → Transformer：抛弃循环，引入注意力 问题：LSTM/GRU 仍需按顺序处理序列，无法并行计算，长序列处
基于深度学习的金枪鱼各类别目标检测含完整数据集
crasher123的博客
06-07 1076
在渔业行业，金枪鱼的捕捞和管理一直是一个巨大的挑战，尤其是在大规模渔业作业中，如何精确地识别并分类不同种类的金枪鱼，是提高捕捞效率和保护生态环境的关键。然而，传统的金枪鱼识别方法依赖人工判断，费时费力，且存在很大的误差和漏检问题。金枪鱼的种类繁多，外形相似，甚至在不同的光照、角度下，金枪鱼的外观变化较大，这使得传统方法在准确性和实时性方面存在很大挑战。金枪鱼目标检测的数据集包含了大量的金枪鱼图像，并对图像中的每一只金枪鱼进行了精确的标注，包括金枪鱼的种类、位置和边界框等信息。
深度学习聊天机器人 需要考虑
mayaohao的博客
06-10 867
优秀的聊天机器人需要 “数据 + 模型 + 策略 + 工程” 的协同优化。对于小规模数据场景，需优先解决数据质量和参数效率问题；而大规模应用则需兼顾泛化性、知识准确性和用户体验。通过持续迭代和多维度优化，逐步提升模型在流畅性、逻辑性、知识性和可控性上的表现。
【深度学习:进阶篇】--2.4.BN与神经网络调优
最新发布
我是个好人呀，O(∩_∩)O
06-11 715
本文介绍了神经网络调优中的超参数选择和批标准化（Batch Normalization）技术。在超参数调优方面，重点阐述了学习率、算法参数等超参数的网格搜索方法及合理取值策略。针对批标准化技术，详细解释了其数学原理（包括标准化公式和引入γ、β参数的修正方法）和应用价值，分析了其通过稳定层输入分布来加速训练、提高模型鲁棒性的作用机制，并指出BN能减弱梯度消失/爆炸问题，降低层间耦合性。最后强调BN应主要作为加速训练的手段而非正则化方法。
【深度学习新浪潮】RoPE对大模型的外推性有什么影响？
agito_cheung的博客
06-06 549
大模型的外推性（Extrapolation）是指模型对训练数据分布之外的输入或场景进行有效推理和生成的能力。简单来说，就是模型处理“未见过的新情况”的能力，这些新情况可能在语义、结构、长度、复杂度等方面超出了训练数据的范围。核心概念解析与内插性（Interpolation）的区别内插性：模型对训练数据中已有模式的合理延伸（例如，训练数据包含“猫”和“狗”，模型能理解“宠物”的概念）。外推性：模型对训练数据中未直接涵盖的模式或边界外的情况。
（十）量子注意力机制：深度学习与量子计算的交叉融合探索
hanyuge的专栏
06-11 784
多头注意力（Multi-Head Attention）是Transformer模型中的关键组件，它通过多个注意力头来捕捉不同维度的信息，从而提高模型的表达能力和性能。这种机制能够使模型在不同的表示子空间中学习到不同的特征模式。自注意力机制的核心思想是通过计算序列中每个位置的查询（Query）、键（Key）和值（Value）向量之间的关系，来确定每个位置对其他位置的注意力权重。在传统的序列模型中，如循环神经网络（RNN），模型在处理每个时间步时，通常会使用固定长度的上下文（如前一个隐藏状态）来生成输出。
多模态人工智能大模型应用及部署总结
资源摘要信息: "网页、视频、图片大模型总结.zip" 提供了一个关于在垂直领域内应用大模型技术的总结，重点在于多模态学习，以及其易于部署的特性，适合学习交流使用。该压缩包内容中包含的文件名为 "open_wei——...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Yuezero_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值