-
Notifications
You must be signed in to change notification settings - Fork 5
/
models_vit_group_channels.py
108 lines (84 loc) · 4.55 KB
/
models_vit_group_channels.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
# --------------------------------------------------------
# References:
# MAE: https://github.com/facebookresearch/mae
# timm: https://github.com/rwightman/pytorch-image-models/tree/master/timm
# --------------------------------------------------------
from functools import partial
import torch
import torch.nn as nn
import torch.nn.functional as F
from timm.models.vision_transformer import VisionTransformer, PatchEmbed
from util.pos_embed import get_2d_sincos_pos_embed, get_1d_sincos_pos_embed_from_grid
class GroupChannelsVisionTransformer(VisionTransformer):
""" Vision Transformer with support for global average pooling
"""
def __init__(self, global_pool=False, channel_embed=256,
channel_groups=((0, 1, 2, 6), (3, 4, 5, 7), (8, 9)), **kwargs):
super().__init__(**kwargs)
img_size = kwargs['img_size']
patch_size = kwargs['patch_size']
in_c = kwargs['in_chans']
embed_dim = kwargs['embed_dim']
self.channel_groups = channel_groups
self.patch_embed = nn.ModuleList([PatchEmbed(img_size, patch_size, len(group), embed_dim)
for group in channel_groups])
num_patches = self.patch_embed[0].num_patches
# Positional and channel embed
self.pos_embed = nn.Parameter(torch.zeros(1, num_patches + 1, embed_dim - channel_embed))
pos_embed = get_2d_sincos_pos_embed(self.pos_embed.shape[-1], int(num_patches ** .5), cls_token=True)
self.pos_embed.data.copy_(torch.from_numpy(pos_embed).float().unsqueeze(0))
num_groups = len(channel_groups)
self.channel_embed = nn.Parameter(torch.zeros(1, num_groups, channel_embed))
chan_embed = get_1d_sincos_pos_embed_from_grid(self.channel_embed.shape[-1], torch.arange(num_groups).numpy())
self.channel_embed.data.copy_(torch.from_numpy(chan_embed).float().unsqueeze(0))
# Extra embedding for cls to fill embed_dim
self.channel_cls_embed = nn.Parameter(torch.zeros(1, 1, channel_embed))
channel_cls_embed = torch.zeros((1, channel_embed))
self.channel_cls_embed.data.copy_(channel_cls_embed.float().unsqueeze(0))
self.global_pool = global_pool
if self.global_pool:
norm_layer = kwargs['norm_layer']
embed_dim = kwargs['embed_dim']
self.fc_norm = norm_layer(embed_dim)
del self.norm # remove the original norm
def forward_features(self, x):
b, c, h, w = x.shape
x_c_embed = []
for i, group in enumerate(self.channel_groups):
x_c = x[:, group, :, :]
x_c_embed.append(self.patch_embed[i](x_c)) # (N, L, D)
x = torch.stack(x_c_embed, dim=1) # (N, G, L, D)
_, G, L, D = x.shape
# add channel embed
channel_embed = self.channel_embed.unsqueeze(2) # (1, c, 1, cD)
pos_embed = self.pos_embed[:, 1:, :].unsqueeze(1) # (1, 1, L, pD)
# Channel embed same across (x,y) position, and pos embed same across channel (c)
channel_embed = channel_embed.expand(-1, -1, pos_embed.shape[2], -1) # (1, c, L, cD)
pos_embed = pos_embed.expand(-1, channel_embed.shape[1], -1, -1) # (1, c, L, pD)
pos_channel = torch.cat((pos_embed, channel_embed), dim=-1) # (1, c, L, D)
# add pos embed w/o cls token
x = x + pos_channel # (N, G, L, D)
x = x.view(b, -1, D) # (N, G*L, D)
cls_pos_channel = torch.cat((self.pos_embed[:, :1, :], self.channel_cls_embed), dim=-1) # (1, 1, D)
cls_tokens = cls_pos_channel + self.cls_token.expand(b, -1, -1)
x = torch.cat((cls_tokens, x), dim=1) # (N, 1 + c*L, D)
x = self.pos_drop(x)
for blk in self.blocks:
x = blk(x)
if self.global_pool:
x = x[:, 1:, :].mean(dim=1) # global pool without cls token
outcome = self.fc_norm(x)
else:
x = self.norm(x)
outcome = x[:, 0]
return outcome
def vit_base_patch16(**kwargs):
model = GroupChannelsVisionTransformer(channel_embed=256, embed_dim=768, depth=12,
num_heads=12, mlp_ratio=4, qkv_bias=True,
norm_layer=partial(nn.LayerNorm, eps=1e-6), **kwargs)
return model
def vit_large_patch16(**kwargs):
model = GroupChannelsVisionTransformer(channel_embed=256, embed_dim=1024, depth=24,
num_heads=16, mlp_ratio=4, qkv_bias=True,
norm_layer=partial(nn.LayerNorm, eps=1e-6), **kwargs)
return model