| import torch |
| import torch.nn as nn |
| import torch.nn.functional as F |
| import torch.utils.checkpoint as checkpoint |
| import numpy as np |
| from timm.models.layers import DropPath, trunc_normal_ |
|
|
| class Mlp(nn.Module): |
| def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.): |
| super().__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_layer() |
| 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 |
|
|
| def window_partition(x, window_size): |
| B, H, W, C = x.shape |
| x = x.view(B, H // window_size, window_size, W // window_size, window_size, C) |
| windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C) |
| return windows |
|
|
| def window_reverse(windows, window_size, H, W): |
| B = int(windows.shape[0] / (H * W / window_size / window_size)) |
| x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1) |
| x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1) |
| return x |
|
|
| class WindowAttention(nn.Module): |
| def __init__(self, dim, window_size, num_heads, qkv_bias=True, attn_drop=0., proj_drop=0.): |
| super().__init__() |
| self.dim = dim |
| self.window_size = window_size |
| self.num_heads = num_heads |
| head_dim = dim // num_heads |
| self.scale = head_dim ** -0.5 |
|
|
| self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias) |
| self.attn_drop = nn.Dropout(attn_drop) |
| self.proj = nn.Linear(dim, dim) |
| self.proj_drop = nn.Dropout(proj_drop) |
|
|
| self.softmax = nn.Softmax(dim=-1) |
|
|
| def forward(self, x): |
| B_, N, C = x.shape |
| qkv = self.qkv(x).reshape(B_, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4) |
| q, k, v = qkv[0], qkv[1], qkv[2] |
|
|
| q = q * self.scale |
| attn = (q @ k.transpose(-2, -1)) |
| attn = self.softmax(attn) |
| attn = self.attn_drop(attn) |
|
|
| x = (attn @ v).transpose(1, 2).reshape(B_, N, C) |
| x = self.proj(x) |
| x = self.proj_drop(x) |
| return x |
|
|
| class SwinTransformerBlock(nn.Module): |
| def __init__(self, dim, num_heads, window_size=7, shift_size=0, |
| mlp_ratio=4., qkv_bias=True, drop=0., attn_drop=0., drop_path=0., |
| act_layer=nn.GELU, norm_layer=nn.LayerNorm): |
| super().__init__() |
| self.dim = dim |
| self.num_heads = num_heads |
| self.window_size = window_size |
| self.shift_size = shift_size |
| self.mlp_ratio = mlp_ratio |
|
|
| self.norm1 = norm_layer(dim) |
| self.attn = WindowAttention( |
| dim, window_size=window_size, num_heads=num_heads, |
| qkv_bias=qkv_bias, attn_drop=attn_drop, proj_drop=drop) |
|
|
| self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity() |
| self.norm2 = norm_layer(dim) |
| mlp_hidden_dim = int(dim * mlp_ratio) |
| self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop) |
|
|
| def forward(self, x): |
| H, W = self.H, self.W |
| B, L, C = x.shape |
| assert L == H * W, "input feature has wrong size" |
|
|
| shortcut = x |
| x = self.norm1(x) |
| x = x.view(B, H, W, C) |
|
|
| |
| pad_l = pad_t = 0 |
| pad_r = (self.window_size - W % self.window_size) % self.window_size |
| pad_b = (self.window_size - H % self.window_size) % self.window_size |
| x = F.pad(x, (0, 0, pad_l, pad_r, pad_t, pad_b)) |
| _, Hp, Wp, _ = x.shape |
|
|
| |
| if self.shift_size > 0: |
| shifted_x = torch.roll(x, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2)) |
| else: |
| shifted_x = x |
|
|
| |
| x_windows = window_partition(shifted_x, self.window_size) |
| x_windows = x_windows.view(-1, self.window_size * self.window_size, C) |
|
|
| |
| attn_windows = self.attn(x_windows) |
|
|
| |
| attn_windows = attn_windows.view(-1, self.window_size, self.window_size, C) |
| shifted_x = window_reverse(attn_windows, self.window_size, Hp, Wp) |
|
|
| |
| if self.shift_size > 0: |
| x = torch.roll(shifted_x, shifts=(self.shift_size, self.shift_size), dims=(1, 2)) |
| else: |
| x = shifted_x |
|
|
| if pad_r > 0 or pad_b > 0: |
| x = x[:, :H, :W, :].contiguous() |
|
|
| x = x.view(B, H * W, C) |
|
|
| |
| x = shortcut + self.drop_path(x) |
| x = x + self.drop_path(self.mlp(self.norm2(x))) |
|
|
| return x |
|
|
| class PatchEmbed(nn.Module): |
| def __init__(self, patch_size=4, in_chans=3, embed_dim=96, norm_layer=None): |
| super().__init__() |
| self.patch_size = patch_size |
| self.in_chans = in_chans |
| self.embed_dim = embed_dim |
|
|
| self.proj = nn.Conv2d(in_chans, 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): |
| _, _, H, W = x.shape |
| |
| |
| pad_input = (H % self.patch_size != 0) or (W % self.patch_size != 0) |
| if pad_input: |
| x = F.pad(x, (0, self.patch_size - W % self.patch_size, |
| 0, self.patch_size - H % self.patch_size, |
| 0, 0)) |
| |
| x = self.proj(x) |
| x = x.flatten(2).transpose(1, 2) |
| x = self.norm(x) |
| return x |
|
|
| class SwinTransformer(nn.Module): |
| def __init__(self, img_size=32, patch_size=4, in_chans=3, num_classes=10, |
| embed_dim=96, depths=[2, 2, 6, 2], num_heads=[3, 6, 12, 24], |
| window_size=7, mlp_ratio=4., qkv_bias=True, |
| drop_rate=0., attn_drop_rate=0., drop_path_rate=0.1, |
| norm_layer=nn.LayerNorm, patch_norm=True): |
| super().__init__() |
|
|
| self.num_classes = num_classes |
| self.num_layers = len(depths) |
| self.embed_dim = embed_dim |
| self.patch_norm = patch_norm |
| |
| |
| self.patch_embed = PatchEmbed( |
| patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim, |
| norm_layer=norm_layer if self.patch_norm else None) |
|
|
| self.pos_drop = nn.Dropout(p=drop_rate) |
|
|
| |
| layers = [] |
| for i_layer in range(self.num_layers): |
| layer = SwinTransformerBlock( |
| dim=embed_dim, |
| num_heads=num_heads[i_layer], |
| window_size=window_size, |
| shift_size=0 if (i_layer % 2 == 0) else window_size // 2, |
| mlp_ratio=mlp_ratio, |
| qkv_bias=qkv_bias, |
| drop=drop_rate, |
| attn_drop=attn_drop_rate, |
| drop_path=drop_path_rate, |
| norm_layer=norm_layer) |
| layers.append(layer) |
|
|
| self.layers = nn.ModuleList(layers) |
| self.norm = norm_layer(embed_dim) |
| self.avgpool = nn.AdaptiveAvgPool1d(1) |
| self.head = nn.Linear(embed_dim, num_classes) |
|
|
| self.apply(self._init_weights) |
|
|
| def _init_weights(self, m): |
| if isinstance(m, nn.Linear): |
| trunc_normal_(m.weight, std=.02) |
| if isinstance(m, nn.Linear) and m.bias is not None: |
| nn.init.constant_(m.bias, 0) |
| elif isinstance(m, nn.LayerNorm): |
| nn.init.constant_(m.bias, 0) |
| nn.init.constant_(m.weight, 1.0) |
|
|
| def forward(self, x): |
| x = self.patch_embed(x) |
| x = self.pos_drop(x) |
|
|
| |
| B, L, C = x.shape |
| H = W = int(L ** 0.5) |
| |
| for layer in self.layers: |
| layer.H, layer.W = H, W |
| x = layer(x) |
|
|
| x = self.norm(x) |
| x = self.avgpool(x.transpose(1, 2)) |
| x = torch.flatten(x, 1) |
| x = self.head(x) |
|
|
| return x |
|
|
| def feature(self, x): |
| x = self.patch_embed(x) |
| x = self.pos_drop(x) |
|
|
| |
| B, L, C = x.shape |
| H = W = int(L ** 0.5) |
| |
| for layer in self.layers: |
| layer.H, layer.W = H, W |
| x = layer(x) |
|
|
| x = self.norm(x) |
| x = self.avgpool(x.transpose(1, 2)) |
|
|
| return x |
|
|
| def prediction(self, x): |
| x = torch.flatten(x, 1) |
| x = self.head(x) |
|
|
| return x |
