[人工智能]基于pytorch的vision transformer模型实现

import torch
import torch.nn as nn
from timm.models.layers import DropPath
from collections import OrderedDict
from functools import partial

class Patch_Embeding(nn.Module):
    def __init__(self, img_size=224, patch_size=16, in_channel=3, embed_dim=768, norm_layer=None):
        super(Patch_Embeding, self).__init__()

        img_size = (img_size, img_size)
        patch_size = (patch_size, patch_size)
        self.img_size = img_size
        self.patch_size = patch_size
        self.grid_size = (img_size[0] // patch_size[0], img_size[1] // patch_size[1])
        self.num_paches = self.grid_size[0] * self.grid_size[1]

        self.proj = nn.Conv2d(in_channel, embed_dim, kernel_size=patch_size, stride=patch_size)
        self.norm = norm_layer(embed_dim) if norm_layer else nn.Identity()

    def forward(self, x):
        B, C, H, W = x.shape
        # flatten [B, C, H, W] -> [B, C, HW]
        # trans [B, C, HW] -> [B, HW, C] layer norm default对最后的维度做norm
        x = self.proj(x).flatten(2).transpose(1, 2)
        x = self.norm(x)
        return x


class Attention(nn.Module):
    def __init__(self, token_dim, num_heads=8, qkv_bias=False, qkv_scale=None, attn_drop_ratio=0., proj_drop_ratio=0.):
        super(Attention, self).__init__()

        self.num_heads = num_heads
        head_dim = token_dim // num_heads
        self.scale = qkv_scale or head_dim ** -0.5
        self.qkv = nn.Linear(token_dim, token_dim * 3, bias=qkv_bias)
        self.attn_drop = nn.Dropout(attn_drop_ratio)
        self.proj = nn.Linear(token_dim, token_dim)
        self.proj_drop = nn.Dropout(proj_drop_ratio)

    def forward(self, x):
        # [batch size, num_patches + 1, total_embed_dim]
        B, N, C = x.shape
        # qkv() -> [batch size, num_patches + 1, 3 * total_embed_dim]
        # 3 表示拆分成qkv对应的参数 C // self.num_heads表示每个头中的dim
        # reshape -> [batch size, num_patches + 1, 3, num_heads, embed_dim_per_head]
        # permute -> [3, batch size, num_heads, num_patches + 1, embed_dim_per_head]
        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
        # [batch size, num_heads, num_patches + 1, embed_dim_per_head]
        q, k, v = qkv[0], qkv[1], qkv[2]
        # transpose: -> [batch size, num_heads, embed_dim_per_head, num_patches + 1]
        # @: multiply: -> [batch size, num_heads, num_patches + 1, num_patches + 1]
        attn = (q @ k.transpose(-1, -2)) * self.scale
        attn = attn.softmax(dim=-1) # dim=-1 按行进行softmax
        attn = self.attn_drop(attn)
        # @: multiply: attn: [batch size, num_heads, num_patches + 1, num_patches + 1]
        # v: [batch size, num_heads, num_patches + 1, embed_dim_per_head]
        # -> [batch size, num_heads, num_patches + 1, embed_dim_per_head]
        # transpose: -> [batch size, num_patches + 1, num_heads, embed_dim_per_head]
        # reshape： 拼接最后两个维度 -> [batch size, num_patches + 1, total_embed_dim]
        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
        x = self.proj(x)
        x = self.proj_drop(x)

        return x


class Encoder_Block_MLP(nn.Module):
    def __init__(self, in_features, hidden_features=None, out_features=None, act=nn.GELU, drop=0.):
        super(Encoder_Block_MLP, self).__init__()

        out_features = out_features or in_features
        hidden_features = hidden_features or in_features
        self.fc1 = nn.Linear(in_features, hidden_features)
        self.act = act()
        self.fc2 = nn.Linear(hidden_features, out_features)
        self.drop = nn.Dropout(drop)

    def forward(self, x):
        x = self.fc1(x)
        x = self.act(x)
        x = self.drop(x)
        x = self.fc2(x)
        x = self.drop(x)

        return x


class Encoder_Block(nn.Module):
    def __init__(self, token_dim, num_heads, mlp_ratio=4, qkv_bias=False, qkv_scale=None, drop_ratio=0., attn_drop_ratio=0., drop_path_ratio=0., act=nn.GELU, norm_layer=nn.LayerNorm):
        super(Encoder_Block, self).__init__()

        self.norm1 = norm_layer(token_dim)
        self.attn = Attention(token_dim, num_heads=num_heads, qkv_bias=qkv_bias, qkv_scale=qkv_scale, attn_drop_ratio=attn_drop_ratio, proj_drop_ratio=drop_ratio)
        self.drop_path = DropPath(drop_path_ratio) if drop_path_ratio > 0. else nn.Identity()
        self.norm2 = norm_layer(token_dim)
        mlp_hidden_dim = int(token_dim * mlp_ratio)
        self.mlp = Encoder_Block_MLP(in_features=token_dim, hidden_features=mlp_hidden_dim, act=act, drop=drop_ratio)

    def forward(self, x):
        x = x + self.drop_path(self.attn(self.norm1(x)))
        x = x + self.drop_path(self.mlp(self.norm2(x)))

        return x


def _init_vit_weights(m):
    """
    ViT weight initialization
    :param m: module
    """
    if isinstance(m, nn.Linear):
        nn.init.trunc_normal_(m.weight, std=.01)
        if m.bias is not None:
            nn.init.zeros_(m.bias)
    elif isinstance(m, nn.Conv2d):
        nn.init.kaiming_normal_(m.weight, mode="fan_out")
        if m.bias is not None:
            nn.init.zeros_(m.bias)
    elif isinstance(m, nn.LayerNorm):
        nn.init.zeros_(m.bias)
        nn.init.ones_(m.weight)


class VisionTransformer(nn.Module):
    def __init__(self, img_size=224, patch_size=16, in_channel=3, num_classes=1000, embed_dim=768, depth=12, num_heads=12, mlp_ratio=4.0, qkv_bias=True, qkv_scale=None, representation_size=None,
                 drop_raio=0., attn_drop_ratio=0., drop_path_ratio=0., embed_layer=Patch_Embeding):

        super(VisionTransformer, self).__init__()

        self.num_classes = num_classes
        self.num_features = self.embed_dim = embed_dim
        self.num_token = 1
        # norm_layer = partial(nn.LayerNorm, eps=1e-6)
        norm_layer = nn.LayerNorm
        act_layer = nn.GELU

        self.patch_embed = embed_layer(img_size=img_size, patch_size=patch_size, in_channel=in_channel, embed_dim=embed_dim)
        num_patches = self.patch_embed.num_paches

        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
        self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + self.num_token, embed_dim))
        self.pos_drop = nn.Dropout(p=drop_raio)

        dpr = [x.item() for x in torch.linspace(0, drop_path_ratio, depth)]
        self.transformer_block = nn.Sequential(
            *[Encoder_Block(token_dim=embed_dim, num_heads=num_heads, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qkv_scale=qkv_scale,
                            drop_ratio=drop_raio, attn_drop_ratio=attn_drop_ratio, drop_path_ratio=dpr[i], norm_layer=norm_layer, act=act_layer) for i in range(depth)]
        )

        self.norm = norm_layer(embed_dim)

        if representation_size is not None:
            self.has_logits = True
            self.num_features = representation_size
            self.pre_logits = nn.Sequential(
                OrderedDict([
                    ('fc', nn.Linear(embed_dim, representation_size)),
                    ('act', nn.Tanh())
                ])
            )
        else:
            self.has_logits = False
            self.pre_logits = nn.Identity()

        self.head = nn.Linear(self.num_features, num_classes)

        # init weight
        nn.init.trunc_normal_(self.pos_embed, std=0.02)
        nn.init.trunc_normal_(self.cls_token, std=0.02)
        self.apply(_init_vit_weights)

    def forward_feature(self, x):
        # [B, C, H, W] -> [B, num_patches, embed_dim]
        x = self.patch_embed(x) # [B, 196, 768]
        # [1, 1, 768] -> [B, 1, 768]
        cls_token = self.cls_token.expand(x.shape[0], -1, -1)
        # position embedding [B, 197, 768]
        x = torch.cat((cls_token, x), dim=1)
        #  patch embedding + position embedding
        x = self.pos_drop(x + self.pos_embed)
        # transformer block
        x = self.transformer_block(x)
        x = self.norm(x)
        return self.pre_logits(x[:, 0])

    def forward(self, x):
        x = self.forward_feature(x)
        x = self.head(x)
        return x


def ViT_Base():
    model = VisionTransformer(img_size=224, patch_size=16, embed_dim=768, depth=12, num_heads=12, representation_size=None, num_classes=1000)
    return model


if __name__ == '__main__':
    rgb = torch.randn(1, 3, 224, 224)
    model = ViT_Base()
    output = model(rgb)
    print(output.shape)