目录

小米-多模态算法工程师

1、对多模态大模型的了解

1.1 CLIP

CLIP利用对比学习（Contrastive Learning）对图像和文本进行联合训练。

1.2 BLIP

原文在这里插入图片描述

BLIP的模型架构包括4个关键部分：图像编码器、文本编码器、图像-文本匹配编码器和图像-文本解码器

  1. Image Encoder ：VIT 用于提取图像特征
  2. Text Encoder：BLIP使用了BERT作为文本编码器。
  3. 图像-文本匹配编码器 (Image-grounded Text Encoder): 用于判断当前的文本描述和图像是否匹配，进行图像-文本的匹配任务。
    该模型的输入是图像特征（通过图像编码器提取）和文本特征（通过文本编码器提取），并通过交叉注意力机制（Cross Attention）在每个Transformer层中结合视觉特征。
  4. 图像-文本解码器 (Image-grounded Text Decoder)： 用于生成图像的文本描述（caption）。该模块的架构与图像-文本匹配编码器相似，同样采用交叉注意力机制，将图像特征与文本特征结合进行生成任务。
    在这里插入图片描述

1.3 BLIP-2

在这里插入图片描述

BLIP-2 的主要目标是通过cross-modal alignment（跨模态对齐）来连接图像和文本之间的差距。它包含两个主要的学习阶段：
①Representation Learning：通过 Q-Former 提取与文本相关的图像特征。
BLIP-2 使用了 Q-Former 框架，包含两个Transformer结构-Former-Image 和 Q-Former-Text。这两个模型通过交叉注意力机制相互关注，从而有效地从视觉和文本中提取相关的特征。其中 Q-Former-Image：负责处理图像信息，它的输入是一个可学习的 query 向量集，这些查询向量经过 Q-Former-Image 后，输出图像的特征。Q-Former-Text：负责处理文本信息，它的输入是文本特征，并通过与图像特征的交叉注意力机制来提取文本相关的视觉特征。Q-Former 以交叉注意力的方式关注冻结的图像编码器提取的视觉特征，确保图像的视觉信息能够被有效地映射到文本特征空间中。
通过三个损失进行优化 Image-Text Contrastive Learning (ITC) Image-grounded Text Generation (ITG) Image-Text Matching (ITM)

②Generative Learning：将 Q-Former 提取的视觉特征对齐到文本模态，利用下游的大语言模型（LLM）进行进一步的生成任务。
在这里插入图片描述

BLIP-2 将 Q-Former 提取的视觉特征对齐到文本模态，并通过一个线性层将其转化为文本特征，送入下游的大语言模型（LLM）。

2、文生图、图生图？

经典的文生图模型如 AttnGAN 和 StackGAN，利用多层次的生成网络逐步生成高分辨率的图像。
变分自编码器（VAE） 和 扩散模型
Transformer模型

3、目前的图像或视频编码器，核心思想方法是什么？

编码器负责将图像或视频输入转换为高维特征表示，这些特征会被后续的模型（如分类器、生成器、检测器等）使用

  • 卷积神经网络（CNN）：CNN 是传统图像编码器的核心，早期的模型如 VGG16 和 ResNet 利用卷积层和池化层提取图像的低级和高级特征 . ResNet VGG16
  • Transformer Vision Transformer (ViT)

对于视频编码器

  • 3D卷积层
  • 双流网络
  • TimeSformer

4、GPT

在这里插入图片描述
在这里插入图片描述

Decoder-only 架构之所以成为大模型主流，核心原因在于：
训练目标统一、自回归生成天然匹配、结构简单、可扩展性强，并且更适合大规模无监督预训练。
它能够将不同任务统一建模为“预测下一个 token”的问题，在规模扩大后自然涌现出指令理解、推理和多任务能力，这是 Encoder-only 和 Encoder–Decoder 架构难以做到的。

4、语义分割模型与指标

4.1 Unet

U-Net 是对称编码器 - 解码器架构，专为医学图像分割设计，核心是通过编码器提取特征、解码器恢复空间分辨率，结合跳跃连接补充分割细节。跳跃连接：解决下采样导致的空间信息丢失，是 U-Net 分割精度高的关键；损失函数：常用 Dice Loss，解决医学图像分割的类别不平衡问题。

4.2 DeepLab

DeepLab 是基于空洞卷积 + 空间金字塔池化的图像分割架构，主打解决语义分割中多尺度目标 + 细节丢失 + 计算效率问题，适合通用场景语义分割。
空洞空间金字塔池化（ASPP）：
对骨干网络输出特征图，并行使用不同速率的空洞卷积（如 1,6,12,18）+ 全局平均池化，捕捉多尺度上下文信息；所有分支输出特征图拼接后，用 1×1 卷积降维，统一特征表达。
Decoder 模块（V3 + 新增）：
上采样 ASPP 输出特征图，与骨干网络浅层特征图（含细节信息）融合；
再通过卷积细化特征，恢复空间分辨率，输出分割掩码

4.3 语义分割的损失函数

在这里插入图片描述

4.4 评价指标

在这里插入图片描述

5、注意力的优化

5.1 多头注意力

# MQA：Multi-Query Attention 所有头共享单组KV
class MQA(nn.Module):
    def __init__(self, dim, n_heads):
        super().__init__()
        self.n_heads = n_heads
        self.head_dim = dim // n_heads
        # Q：多头投影；KV：共享单组投影（无分头）
        self.q_proj = nn.Linear(dim, dim)
        self.k_proj = nn.Linear(dim, self.head_dim)  # 关键：只输出1组KV
        self.v_proj = nn.Linear(dim, self.head_dim)
        self.out_proj = nn.Linear(dim, dim)

    def forward(self, x):
        B, L, D = x.shape
        # Q 分头 [B, H, L, hd]
        q = self.q_proj(x).view(B, L, self.n_heads, self.head_dim).transpose(1, 2)
        # KV 无分头，直接扩展到所有头 [B, 1, L, hd] → [B, H, L, hd]
        k = self.k_proj(x).unsqueeze(1).expand(B, self.n_heads, L, self.head_dim)
        v = self.v_proj(x).unsqueeze(1).expand(B, self.n_heads, L, self.head_dim)
        # 标准注意力
        attn = F.softmax(q @ k.transpose(-2, -1) / self.head_dim**0.5, dim=-1)
        out = (attn @ v).transpose(1,2).contiguous().view(B,L,D)
        return self.out_proj(out)

5.2 KV Cache

import torch
import torch.nn as nn
import torch.nn.functional as F

# 标准 MHA + KV Cache（自回归推理专用）
class MHA_KV_Cache(nn.Module):
    def __init__(self, dim, n_heads):
        super().__init__()
        self.n_heads = n_heads
        self.head_dim = dim // n_heads
        
        # 标准 MHA：QKV 都是 n_heads 个头，完全对等
        self.q_proj = nn.Linear(dim, dim)
        self.k_proj = nn.Linear(dim, dim)
        self.v_proj = nn.Linear(dim, dim)
        self.out_proj = nn.Linear(dim, dim)

        # KV 缓存：保存历史所有 token 的 K、V
        self.k_cache = None
        self.v_cache = None

    def forward(self, x, use_cache=True):
        B, L, D = x.shape  # L=1 推理时每次只来一个新 token
        
        # 1. 新 token 算 QKV（只算当前新 token）
        q = self.q_proj(x).view(B, L, self.n_heads, self.head_dim).transpose(1, 2)  # [B, H, L, hd]
        k = self.k_proj(x).view(B, L, self.n_heads, self.head_dim).transpose(1, 2)
        v = self.v_proj(x).view(B, L, self.n_heads, self.head_dim).transpose(1, 2)

        # 2. KV Cache 核心：拼接历史 + 更新缓存
        if use_cache and self.k_cache is not None:
            # 拼接历史所有 KV + 新 KV（只在序列维度拼接）
            k = torch.cat([self.k_cache, k], dim=2)
            v = torch.cat([self.v_cache, v], dim=2)
        
        # 更新缓存：保存到现在为止的全部 K、V
        self.k_cache = k.detach()
        self.v_cache = v.detach()

        # 3. 标准 MHA 注意力计算
        attn_score = q @ k.transpose(-2, -1) / (self.head_dim ** 0.5)
        attn = F.softmax(attn_score, dim=-1)
        out = attn @ v

        # 4. 拼接多头 → 输出
        out = out.transpose(1, 2).contiguous().view(B, L, D)
        return self.out_proj(out)

    def reset(self):
        # 新对话清空缓存
        self.k_cache = None
        self.v_cache = None

5.3 GQA 分组查询注意力

基础信息
论文：LLaMA 2 (2023) / GQA: Training Generalized Multi-Query Transformer Models
核心思想：Q 分组，每组共享 1 组 KV；平衡 MHA（精度）和 MQA（速度）
参数：num_heads(Q 头数) / num_kv_heads(KV 组数)
LLaMA2-70B：heads=64, kv_heads=8 → 8 组，每组 8 个 Q 共享 1 组 KV

# GQA：Grouped-Query Attention 工业界标准实现
class GQA(nn.Module):
    def __init__(self, dim, n_heads, n_kv_heads):
        super().__init__()
        self.n_heads = n_heads
        self.n_kv_heads = n_kv_heads
        self.head_dim = dim // n_heads
        # KV头数 < Q头数，分组共享
        self.q_proj = nn.Linear(dim, n_heads * self.head_dim)
        self.k_proj = nn.Linear(dim, n_kv_heads * self.head_dim)
        self.v_proj = nn.Linear(dim, n_kv_heads * self.head_dim)
        self.out_proj = nn.Linear(dim, dim)

    def forward(self, x):
        B, L, D = x.shape
        # QKV 投影
        q = self.q_proj(x).view(B, L, self.n_heads, self.head_dim).transpose(1, 2)
        k = self.k_proj(x).view(B, L, self.n_kv_heads, self.head_dim).transpose(1, 2)
        v = self.v_proj(x).view(B, L, self.n_kv_heads, self.head_dim).transpose(1, 2)
        
        # 核心：KV 重复分组，匹配Q的头数
        k = k.repeat(1, self.n_heads // self.n_kv_heads, 1, 1)
        v = v.repeat(1, self.n_heads // self.n_kv_heads, 1, 1)
        
        # 注意力计算
        attn = F.softmax(q @ k.transpose(-2, -1) / self.head_dim**0.5, dim=-1)
        out = (attn @ v).transpose(1, 2).contiguous().view(B, L, D)
        return self.out_proj(out)
# 算法
Logo
AtomGit开源社区

AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。

更多推荐

cover

昇腾 0 Day 支持 Hunyuan4-preview，770B MoE 旗舰模型开源即适配

avatar AtomGit开源社区
cover

昇腾 CANN 算子实操工坊 · 9月5日上海站启动报名｜从“围观者”到“贡献者”，一场工坊的距离

avatar AtomGit开源社区
cover

把 Agent 装进桌面：dsh-desktop 入驻 AtomGit

avatar AtomGit开源社区