视觉-语言模型-出发点CLIP--(挖掘源码-网络框架)

1.网络架构

建议配合 clip原理一起来品尝你的视觉语言之旅

2.模块

2.1 构建残差块 (也是resnet)

class Bottleneck(nn.Module):
    expansion = 4

    def __init__(self, inplanes, planes, stride=1):
        super().__init__()

        # all conv layers have stride 1. an avgpool is performed after the second convolution when stride > 1
        #1x1
        self.conv1 = nn.Conv2d(inplanes, planes, 1, bias=False)
        # 在某些情况下，不使用偏置项并不会影响模型的表达能力。
        # 因为后续的归一化层和激活函数可以通过其他方式实现类似的平移效果。
        self.bn1 = nn.BatchNorm2d(planes)
        self.relu1 = nn.ReLU(inplace=True)
        #当inplace=True 时，表示直接在输入的张量上进行修改，而不是创建一个新的张量来存储输出结果
        #这样可以节省内存，但可能会影响代码的可读性和调试。

        #3x3
        self.conv2 = nn.Conv2d(planes, planes, 3, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(planes)
        self.relu2 = nn.ReLU(inplace=True)

        #nn.Identity 恒等映射层的作用是直接将输入原封不动地输出，也就是输出和输入完全相同.
        #仅传入了 stride 参数，这意味着池化窗口的大小和步长均为 stride
        self.avgpool = nn.AvgPool2d(stride) if stride > 1 else nn.Identity()

        self.conv3 = nn.Conv2d(planes, planes * self.expansion, 1, bias=False)
        self.bn3 = nn.BatchNorm2d(planes * self.expansion)
        self.relu3 = nn.ReLU(inplace=True)

        self.downsample = None
        self.stride = stride

        if stride > 1 or inplanes != planes * Bottleneck.expansion:
            # downsampling layer is prepended with an avgpool, and the subsequent convolution has stride 1
            #OrderedDict 取名
            #需要逐步减小特征图的尺寸以提取更高级、更抽象的特征
            self.downsample = nn.Sequential(OrderedDict([
                ("-1", nn.AvgPool2d(stride)),
                ("0", nn.Conv2d(inplanes, planes * self.expansion, 1, stride=1, bias=False)),
                ("1", nn.BatchNorm2d(planes * self.expansion))
            ]))
     def forward(self, x: torch.Tensor):
        identity = x
        out = self.relu1(self.bn1(self.conv1(x)))
        out = self.relu2(self.bn2(self.conv2(out)))
        out = self.avgpool(out)
        out = self.bn3(self.conv3(out))

        if self.downsample is not None:
            identity = self.downsample(x)

        out += identity#f(x)1=f(x)+x
        out = self.relu3(out)
        return out

实现了一个残差块 可以即插即用 返回 #[N,planes * self.expansion,H,C]

2.2 注意力池化

class AttentionPool2d(nn.Module):
    def __init__(self, spacial_dim: int, embed_dim: int, num_heads: int, output_dim: int = None):
        super().__init__()
        self.positional_embedding = nn.Parameter(torch.randn(spacial_dim ** 2 + 1, embed_dim) / embed_dim ** 0.5)
        self.k_proj = nn.Linear(embed_dim, embed_dim)
        self.q_proj = nn.Linear(embed_dim, embed_dim)
        self.v_proj = nn.Linear(embed_dim, embed_dim)
        self.c_proj = nn.Linear(embed_dim, output_dim or embed_dim)#为真就
        self.num_heads = num_heads

    def forward(self, x):
        x = x.flatten(start_dim=2).permute(2, 0, 1)  # NCHW -> (HW)NC
        x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0)  # (HW+1)NC
        x = x + self.positional_embedding[:, None, :].to(x.dtype)  # (HW+1)NC
        x, _ = F.multi_head_attention_forward(
            query=x[:1], key=x, value=x,#也就是 [CLS] 标记对应的特征向量，让它作为查询去关注图像中所有小块（以及它自身）的信息。
            embed_dim_to_check=x.shape[-1],
            num_heads=self.num_heads,
            q_proj_weight=self.q_proj.weight,
            k_proj_weight=self.k_proj.weight,
            v_proj_weight=self.v_proj.weight,
            in_proj_weight=None,#不统一用
            in_proj_bias=torch.cat([self.q_proj.bias, self.k_proj.bias, self.v_proj.bias]),
            bias_k=None,
            bias_v=None,
            add_zero_attn=False,
            dropout_p=0,
            out_proj_weight=self.c_proj.weight,
            out_proj_bias=self.c_proj.bias,
            use_separate_proj_weight=True,
            training=self.training,
            need_weights=False
        )
        return x.squeeze(0)

返回了[batch_size, embedding_dim]

2.3 重定义层归一化

class LayerNorm(nn.LayerNorm):
    """Subclass torch's LayerNorm to handle fp16."""

    def forward(self, x: torch.Tensor):
        orig_type = x.dtype
        ret = super().forward(x.type(torch.float32))
        return ret.type(orig_type)
#功能：对输入进行层归一化，处理 fp16 数据类型。
#前向传播：将输入转换为 float32 类型进行归一化，再转换回原始数据类型输出。

方便计算

2.4 快速计算

class QuickGELU(nn.Module):
    def forward(self, x: torch.Tensor):
        return x * torch.sigmoid(1.702 * x)
        #QuickGELU 提供了一种对标准 GELU 函数的近似实现，
        #在保持相近效果的同时，具有更快的计算速度

2.5 残差注意力模块

class ResidualAttentionBlock(nn.Module):
    def __init__(self, d_model: int, n_head: int, attn_mask: torch.Tensor = None):
        super().__init__()

        self.attn = nn.MultiheadAttention(d_model, n_head)
        self.ln_1 = LayerNorm(d_model)
        self.mlp = nn.Sequential(OrderedDict([
            ("c_fc", nn.Linear(d_model, d_model * 4)),
            ("gelu", QuickGELU()),
            ("c_proj", nn.Linear(d_model * 4, d_model))
        ]))
        self.ln_2 = LayerNorm(d_model)
        self.attn_mask = attn_mask

    def attention(self, x: torch.Tensor):
        self.attn_mask = self.attn_mask.to(dtype=x.dtype, device=x.device) if self.attn_mask is not None else None
        return self.attn(x, x, x, need_weights=False, attn_mask=self.attn_mask)[0]
        #即多头注意力的输出。
        # x x x分别是 k q v

    def forward(self, x: torch.Tensor):
        x = x + self.attention(self.ln_1(x))
        x = x + self.mlp(self.ln_2(x))
        return x

2.6 重定义 transform

class Transformer(nn.Module):
    def __init__(self, width: int, layers: int, heads: int, attn_mask: torch.Tensor = None):
        super().__init__()
        self.width = width
        self.layers = layers
        self.resblocks = nn.Sequential(*[ResidualAttentionBlock(width, heads, attn_mask) for _ in range(layers)])

    def forward(self, x: torch.Tensor):
        return self.resblocks(x)
        #* 是 Python 中的解包操作符。当用于列表或元组前时，它会将列表或元组中的元素解包，
        #将其作为单独的参数传递给函数或用于其他需要多个参数的地方。
        #例如，假设我们有一个列表 lst = [1, 2, 3]，print(*lst) 就相当于 print(1, 2, 3)#

参数介绍 width 输入维度（词嵌入向量） layers 叠加层数 heads 多头也就是(几重注意力机制)

2.7 重定义VIT （图片编码器）

class VisionTransformer(nn.Module):
    def __init__(self, input_resolution: int, patch_size: int, width: int, layers: int, heads: int, output_dim: int):
        super().__init__()
        self.input_resolution = input_resolution
        self.output_dim = output_dim
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=width, kernel_size=patch_size, stride=patch_size, bias=False)

        scale = width ** -0.5#维度特征
        self.class_embedding = nn.Parameter(scale * torch.randn(width))
        self.positional_embedding = nn.Parameter(scale * torch.randn((input_resolution // patch_size) ** 2 + 1, width))
        self.ln_pre = LayerNorm(width)

        self.transformer = Transformer(width, layers, heads)

        self.ln_post = LayerNorm(width)
        self.proj = nn.Parameter(scale * torch.randn(width, output_dim))

    def forward(self, x: torch.Tensor):
        x = self.conv1(x)  # shape = [*, width, grid, grid]
        x = x.reshape(x.shape[0], x.shape[1], -1)  # shape = [*, width, grid ** 2]
        x = x.permute(0, 2, 1)  # shape = [*, grid ** 2, width]
        x = torch.cat([self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device), x], dim=1)  # shape = [*, grid ** 2 + 1, width]#初始化
        x = x + self.positional_embedding.to(x.dtype)#这里使用了广播机制进行加法运算
        x = self.ln_pre(x)

        x = x.permute(1, 0, 2)  # NLD -> LND#长度
        x = self.transformer(x)
        x = x.permute(1, 0, 2)  # LND -> NLD

        x = self.ln_post(x[:, 0, :])#N D 关键信息

        if self.proj is not None:
            x = x @ self.proj #[N,1 W][W D] 权重变化

        return x

参数介绍：

input_resolution: int :输入维度之一的长 （对齐 长宽一样）

patch_size: int:patch：块数量 width: int：输出宽度（你可以想象 通道数被映射到高维）

layers: int,:层数 heads: int, output_dim: int 输入维度

返回的是一个N 1 D

2.8 混合精度训练技巧

def convert_weights(model: nn.Module):
    """Convert applicable model parameters to fp16"""

    def _convert_weights_to_fp16(l):
        if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Linear)):
            l.weight.data = l.weight.data.half()
            if l.bias is not None:
                l.bias.data = l.bias.data.half()

        if isinstance(l, nn.MultiheadAttention):
            for attr in [*[f"{s}_proj_weight" for s in ["in", "q", "k", "v"]], "in_proj_bias", "bias_k", "bias_v"]:
                tensor = getattr(l, attr)
                if tensor is not None:
                    tensor.data = tensor.data.half()

        for name in ["text_projection", "proj"]:
            if hasattr(l, name):
                attr = getattr(l, name)
                if attr is not None:
                    attr.data = attr.data.half()

    model.apply(_convert_weights_to_fp16)


###
卷积层和线性层处理：
if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Linear))：检查当前层 l 是否为一维卷积层、二维卷积层或线性层。
l.weight.data = l.weight.data.half()：将这些层的权重数据转换为 fp16 格式。
if l.bias is not None: l.bias.data = l.bias.data.half()：如果这些层有偏置项，也将偏置项的数据转换为 fp16 格式。
多头注意力层处理：
if isinstance(l, nn.MultiheadAttention)：检查当前层是否为多头注意力层。
for attr in [*[f"{s}_proj_weight" for s in ["in", "q", "k", "v"]], "in_proj_bias", "bias_k", "bias_v"]：遍历多头注意力层中的投影权重和偏置项。
tensor = getattr(l, attr)：获取相应的张量。
if tensor is not None: tensor.data = tensor.data.half()：如果张量存在，将其数据转换为 fp16 格式。
特定投影层处理：
for name in ["text_projection", "proj"]：遍历名为 "text_projection" 和 "proj" 的属性。
if hasattr(l, name)：检查当前层是否有这些属性。
attr = getattr(l, name)：获取相应的属性。
if attr is not None: attr.data = attr.data.half()：如果属性存在，将其数据转换为 fp16 格式。

3 CLIP

3.1模型初始化

    def __init__(self,
                 embed_dim: int,
                 # vision
                 image_resolution: int,
                 vision_layers: Union[Tuple[int, int, int, int], int],
                 vision_width: int,
                 vision_patch_size: int,
                 # text
                 context_length: int,
                 vocab_size: int,
                 transformer_width: int,
                 transformer_heads: int,
                 transformer_layers: int
                 ):
        super().__init__()

        self.context_length = context_length

        if isinstance(vision_layers, (tuple, list)):
            vision_heads = vision_width * 32 // 64
            self.visual = ModifiedResNet(
                layers=vision_layers,
                output_dim=embed_dim,
                heads=vision_heads,
                input_resolution=image_resolution,
                width=vision_width
            )
        else:
            vision_heads = vision_width // 64
            self.visual = VisionTransformer(
                input_resolution=image_resolution,
                patch_size=vision_patch_size,
                width=vision_width,
                layers=vision_layers,
                heads=vision_heads,
                output_dim=embed_dim
            )

参数解析：

1. embed_dim: int

• 含义：嵌入维度，即图像特征和文本特征在经过编码器后映射到的特征空间的维度大小。这个维度是图像和文本特征进行对比学习时共享的维度，确保两者可以在同一空间中进行相似度计算。

• 作用：决定了模型最终输出的特征向量的长度，影响模型在特征表示和匹配方面的能力。

2. 视觉编码器相关参数

image_resolution: int

• 含义：输入图像的分辨率，通常是图像的边长（假设图像为正方形）。例如，常见的图像分辨率可以是 224、256 等。

• 作用：用于确定视觉编码器输入图像的大小，不同的分辨率可能会影响模型对图像特征的提取能力。

vision_layers: Union[Tuple[int, int, int, int], int]

• 含义 ：视觉编码器的层数配置。如果是元组 (int, int, int, int) 类型，通常用于 ModifiedResNet 架构，表示四个不同阶段的残差块数量；如果是整数类型，则用于 VisionTransformer 架构，表示 Transformer 层的数量。（只用vit）

• 作用：决定了视觉编码器的深度，影响模型对图像特征的抽象能力和表达能力。

vision_width: int

• 含义 ：视觉编码器中特征图的通道数或者嵌入维度的宽度。在 ModifiedResNet 中，它表示卷积层输出特征图的通道数；在 VisionTransformer 中，它表示每个 patch 嵌入后的向量维度。

• 作用：影响视觉编码器在特征提取过程中的特征表示能力，较大的宽度通常可以提供更丰富的特征信息。

vision_patch_size: int

• 含义 ：在 VisionTransformer 架构中，将输入图像分割成的每个小块（patch）的边长。例如，当 vision_patch_size = 16 时，会将图像分割成多个 16x16 的小块。

• 作用：决定了图像的分割方式，影响模型对图像局部特征的捕捉能力。

3. 文本编码器相关参数

context_length: int

• 含义：输入文本的最大上下文长度，即输入文本序列的最大长度。模型在处理文本时，会将输入文本截断或填充到这个长度。

• 作用：限制了模型能够处理的文本长度，影响模型对长文本的理解能力。

vocab_size: int

• 含义：词汇表的大小，即模型所使用的所有词汇的数量。

• 作用：用于初始化词嵌入层，决定了词嵌入矩阵的行数。

transformer_width: int

• 含义：文本编码器中 Transformer 层的隐藏维度大小，也就是每个词在经过词嵌入后映射到的向量维度。

• 作用：影响文本编码器在处理文本时的特征表示能力和信息传递能力。

transformer_heads: int

• 含义：文本编码器中 Transformer 层的多头注意力机制的头数。多头注意力机制允许模型在不同的表示子空间中并行关注输入序列的不同部分。

• 作用：增加头数可以使模型捕捉到更丰富的文本信息和语义关系。

transformer_layers: int

• 含义：文本编码器中 Transformer 层的数量。

• 作用：决定了文本编码器的深度，影响模型对文本语义的抽象和理解能力。

3.2参数初始化

    def initialize_parameters(self):
    #文本
        nn.init.normal_(self.token_embedding.weight, std=0.02)
        nn.init.normal_(self.positional_embedding, std=0.01)
    
        if self.text_projection is not None:
            nn.init.normal_(self.text_projection, std=self.transformer.width ** -0.5)
    #注意力残差块  
        proj_std = (self.transformer.width ** -0.5) * ((2 * self.transformer.layers) ** -0.5)
        attn_std = self.transformer.width ** -0.5
        fc_std = (2 * self.transformer.width) ** -0.5
        for block in self.transformer.resblocks:
            nn.init.normal_(block.attn.in_proj_weight, std=attn_std)
            nn.init.normal_(block.attn.out_proj.weight, std=proj_std)
            nn.init.normal_(block.mlp.c_fc.weight, std=fc_std)
            nn.init.normal_(block.mlp.c_proj.weight, std=proj_std)

我省去resnet模块的参数初始化

3.3文本编码器

        
        
#参数
self.vocab_size = vocab_size
        self.token_embedding = nn.Embedding(vocab_size, transformer_width)
        self.positional_embedding = nn.Parameter(torch.empty(self.context_length, transformer_width))
        self.ln_final = LayerNorm(transformer_width)

        self.text_projection = nn.Parameter(torch.empty(transformer_width, embed_dim))
    
#掩码操作
def build_attention_mask(self):
    
        mask = torch.empty(self.context_length, self.context_length)
        mask.fill_(float("-inf"))
        mask.triu_(1)  # zero out the lower diagonal
        return mask

def encode_text(self, text):
        x = self.token_embedding(text).type(self.dtype)  # [batch_size, n_ctx, d_model]

        x = x + self.positional_embedding.type(self.dtype)
        x = x.permute(1, 0, 2)  # NLD -> LND
        x = self.transformer(x)
        x = x.permute(1, 0, 2)  # LND -> NLD
        x = self.ln_final(x).type(self.dtype)

        # x.shape = [batch_size, n_ctx, transformer.width]
        # take features from the eot embedding (eot_token is the highest number in each sequence)
        x = x[torch.arange(x.shape[0]), text.argmax(dim=-1)] @ self.text_projection
        # N 1 W W D-> N 1 D

3.4 前向传播

 def forward(self, image, text):
        image_features = self.encode_image(image)
        text_features = self.encode_text(text)

        # normalized features
        image_features = image_features / image_features.norm(dim=1, keepdim=True)
        text_features = text_features / text_features.norm(dim=1, keepdim=True)

        # cosine similarity as logits
        logit_scale = self.logit_scale.exp()
        logits_per_image = logit_scale * image_features @ text_features.t() #   N*N
        logits_per_text = logits_per_image.t()# N*N

        # shape = [global_batch_size, global_batch_size]
        return logits_per_image, logits_per_text

4.如何实现一个简易版

我认为你可以直接将 文本编码器和图片编码器全部换成torch内定义的，最重要的要进行映射

他为什么重定义,其实我们不难发现他想实现混精度训练以及快速高斯归一化（api中不能这样）