341 lines
13 KiB
Python
341 lines
13 KiB
Python
import torch
|
|
import torch.nn as nn
|
|
import torch.nn.functional as F
|
|
from einops import rearrange, repeat
|
|
|
|
from timm.models.layers import DropPath, to_2tuple, trunc_normal_
|
|
import timm
|
|
|
|
import torch
|
|
import torch.nn as nn
|
|
import torch.nn.functional as F
|
|
from einops import rearrange
|
|
from torch.nn.init import trunc_normal_
|
|
class ConvBNReLU(nn.Sequential):
|
|
def __init__(self, in_channels, out_channels, kernel_size=3, dilation=1, stride=1, norm_layer=nn.BatchNorm2d, bias=False):
|
|
super(ConvBNReLU, self).__init__(
|
|
nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, bias=bias,
|
|
dilation=dilation, stride=stride, padding=((stride - 1) + dilation * (kernel_size - 1)) // 2),
|
|
norm_layer(out_channels),
|
|
nn.ReLU6()
|
|
)
|
|
|
|
|
|
class ConvBN(nn.Sequential):
|
|
def __init__(self, in_channels, out_channels, kernel_size=3, dilation=1, stride=1, norm_layer=nn.BatchNorm2d, bias=False):
|
|
super(ConvBN, self).__init__(
|
|
nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, bias=bias,
|
|
dilation=dilation, stride=stride, padding=((stride - 1) + dilation * (kernel_size - 1)) // 2),
|
|
norm_layer(out_channels)
|
|
)
|
|
|
|
|
|
class Conv(nn.Sequential):
|
|
def __init__(self, in_channels, out_channels, kernel_size=3, dilation=1, stride=1, bias=False):
|
|
super(Conv, self).__init__(
|
|
nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size, bias=bias,
|
|
dilation=dilation, stride=stride, padding=((stride - 1) + dilation * (kernel_size - 1)) // 2)
|
|
)
|
|
|
|
|
|
class SelfAttention(nn.Module):
|
|
def __init__(self, dim, num_heads):
|
|
super(SelfAttention, self).__init__()
|
|
self.num_heads = num_heads
|
|
head_dim = dim // self.num_heads
|
|
self.scale = head_dim ** -0.5
|
|
|
|
self.qkv = nn.Linear(dim, 3 * dim)
|
|
self.o_proj = nn.Linear(dim, dim)
|
|
|
|
def forward(self, x):
|
|
B, C, H, W = x.shape
|
|
qkv = self.qkv(x).view(B, -1, self.num_heads, 3, H * W).permute(3, 0, 2, 1, 4)
|
|
q, k, v = qkv[0], qkv[1], qkv[2]
|
|
|
|
dots = torch.matmul(q.transpose(-2, -1), k) * self.scale
|
|
attn = dots.softmax(dim=-1)
|
|
out = torch.matmul(attn, v).transpose(1, 2).reshape(B, C, H, W)
|
|
|
|
return self.o_proj(out)
|
|
|
|
class SeparableConvBNReLU(nn.Sequential):
|
|
def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, dilation=1,
|
|
norm_layer=nn.BatchNorm2d):
|
|
super(SeparableConvBNReLU, self).__init__(
|
|
nn.Conv2d(in_channels, in_channels, kernel_size, stride=stride, dilation=dilation,
|
|
padding=((stride - 1) + dilation * (kernel_size - 1)) // 2,
|
|
groups=in_channels, bias=False),
|
|
norm_layer(out_channels),
|
|
nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False),
|
|
nn.ReLU6()
|
|
)
|
|
|
|
|
|
class SeparableConvBN(nn.Sequential):
|
|
def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, dilation=1,
|
|
norm_layer=nn.BatchNorm2d):
|
|
super(SeparableConvBN, self).__init__(
|
|
nn.Conv2d(in_channels, in_channels, kernel_size, stride=stride, dilation=dilation,
|
|
padding=((stride - 1) + dilation * (kernel_size - 1)) // 2,
|
|
groups=in_channels, bias=False),
|
|
norm_layer(out_channels),
|
|
nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False)
|
|
)
|
|
|
|
|
|
class SeparableConv(nn.Sequential):
|
|
def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, dilation=1):
|
|
super(SeparableConv, self).__init__(
|
|
nn.Conv2d(in_channels, in_channels, kernel_size, stride=stride, dilation=dilation,
|
|
padding=((stride - 1) + dilation * (kernel_size - 1)) // 2,
|
|
groups=in_channels, bias=False),
|
|
nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False)
|
|
)
|
|
|
|
class SEBlock(nn.Module):
|
|
def __init__(self, in_channels, reduction=16):
|
|
super(SEBlock, self).__init__()
|
|
self.avg_pool = nn.AdaptiveAvgPool2d(1)
|
|
self.fc = nn.Sequential(
|
|
nn.Linear(in_channels, in_channels // reduction, bias=False),
|
|
nn.ReLU(inplace=True),
|
|
nn.Linear(in_channels // reduction, in_channels, bias=False),
|
|
nn.Sigmoid()
|
|
)
|
|
|
|
def forward(self, x):
|
|
b, c, _, _ = x.size()
|
|
y = self.avg_pool(x).view(b, c)
|
|
y = self.fc(y).view(b, c, 1, 1)
|
|
return x * y.expand_as(x)
|
|
|
|
class ImprovedLocalAttention(nn.Module):
|
|
def __init__(self, dim):
|
|
super(ImprovedLocalAttention, self).__init__()
|
|
self.conv1x1 = nn.Conv2d(dim, dim, kernel_size=1, bias=False)
|
|
self.conv3x3 = nn.Conv2d(dim, dim, kernel_size=3, padding=1, bias=False)
|
|
self.conv5x5 = nn.Conv2d(dim, dim, kernel_size=5, padding=2, bias=False)
|
|
self.bn = nn.BatchNorm2d(dim)
|
|
self.se = SEBlock(dim)
|
|
|
|
def forward(self, x):
|
|
# Applying different convolutions and combining results
|
|
out1 = self.conv1x1(x)
|
|
out2 = self.conv3x3(x)
|
|
out3 = self.conv5x5(x)
|
|
out = out1 + out2 + out3
|
|
out = self.bn(out)
|
|
out = self.se(out)
|
|
out = out + out1 + out3
|
|
return out
|
|
|
|
|
|
# class MultiHeadGlobalAttention(nn.Module):
|
|
# def __init__(self,
|
|
# dim=256,
|
|
# num_heads=16,
|
|
# qkv_bias=False,
|
|
# window_size=8,
|
|
# relative_pos_embedding=True):
|
|
# super().__init__()
|
|
# self.num_heads = num_heads
|
|
# head_dim = dim // self.num_heads
|
|
# self.scale = head_dim ** -0.5
|
|
# self.ws = window_size
|
|
#
|
|
# self.qkv = nn.Conv2d(dim, 3 * dim, kernel_size=1, bias=qkv_bias)
|
|
# self.proj = nn.Conv2d(dim, dim, kernel_size=1, bias=False)
|
|
#
|
|
# self.relative_pos_embedding = relative_pos_embedding
|
|
#
|
|
# if self.relative_pos_embedding:
|
|
# self.relative_position_bias_table = nn.Parameter(
|
|
# torch.zeros((2 * window_size - 1) * (2 * window_size - 1), num_heads))
|
|
#
|
|
# coords_h = torch.arange(self.ws)
|
|
# coords_w = torch.arange(self.ws)
|
|
# coords = torch.stack(torch.meshgrid([coords_h, coords_w]))
|
|
# coords_flatten = torch.flatten(coords, 1)
|
|
# relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :]
|
|
# relative_coords = relative_coords.permute(1, 2, 0).contiguous()
|
|
# relative_coords[:, :, 0] += self.ws - 1
|
|
# relative_coords[:, :, 1] += self.ws - 1
|
|
# relative_coords[:, :, 0] *= 2 * self.ws - 1
|
|
# relative_position_index = relative_coords.sum(-1)
|
|
# self.register_buffer("relative_position_index", relative_position_index)
|
|
#
|
|
# nn.init.trunc_normal_(self.relative_position_bias_table, std=.02)
|
|
#
|
|
# def pad(self, x, ps):
|
|
# _, _, H, W = x.size()
|
|
# if W % ps != 0:
|
|
# x = F.pad(x, (0, ps - W % ps), mode='reflect')
|
|
# if H % ps != 0:
|
|
# x = F.pad(x, (0, 0, 0, ps - H % ps), mode='reflect')
|
|
# return x
|
|
#
|
|
# def forward(self, x):
|
|
# B, C, H, W = x.shape
|
|
#
|
|
# x = self.pad(x, self.ws)
|
|
# B, C, Hp, Wp = x.shape
|
|
# qkv = self.qkv(x)
|
|
#
|
|
# q, k, v = rearrange(qkv, 'b (qkv h d) (hh ws1) (ww ws2) -> qkv (b hh ww) h (ws1 ws2) d', h=self.num_heads,
|
|
# d=C // self.num_heads, hh=Hp // self.ws, ww=Wp // self.ws, qkv=3, ws1=self.ws, ws2=self.ws)
|
|
#
|
|
# dots = (q @ k.transpose(-2, -1)) * self.scale
|
|
#
|
|
# if self.relative_pos_embedding:
|
|
# relative_position_bias = self.relative_position_bias_table[
|
|
# self.relative_position_index.view(-1)].view(
|
|
# self.ws * self.ws, self.ws * self.ws, -1)
|
|
# relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous()
|
|
# dots += relative_position_bias.unsqueeze(0)
|
|
#
|
|
# attn = dots.softmax(dim=-1)
|
|
# attn = attn @ v
|
|
#
|
|
# attn = rearrange(attn, '(b hh ww) h (ws1 ws2) d -> b (h d) (hh ws1) (ww ws2)', h=self.num_heads,
|
|
# d=C // self.num_heads, hh=Hp // self.ws, ww=Wp // self.ws, ws1=self.ws, ws2=self.ws)
|
|
#
|
|
# attn = attn[:, :, :H, :W]
|
|
#
|
|
# out = self.proj(attn)
|
|
# out = out[:, :, :H, :W]
|
|
#
|
|
# return out
|
|
|
|
# class EffcirntMutilSelfAttention(nn.Module):
|
|
# def __init__(self,
|
|
# dim,
|
|
# num_heads=8,
|
|
# sr_ratio=1):
|
|
# super().__init__()
|
|
# self.num_heads = num_heads
|
|
# head_dim = dim // num_heads
|
|
# self.scale = head_dim ** -0.5
|
|
# self.dim = dim
|
|
#
|
|
# self.q = nn.Conv2d(dim, dim, kernel_size=1, bias=True)
|
|
# self.kv = nn.Conv2d(dim, dim * 2, kernel_size=1, bias=True)
|
|
#
|
|
# self.sr_ratio = sr_ratio
|
|
# if sr_ratio > 1:
|
|
# self.sr = nn.Conv2d(dim, dim, kernel_size=sr_ratio + 1, stride=sr_ratio, padding=sr_ratio // 2, groups=dim)
|
|
# self.sr_norm = nn.LayerNorm(dim, eps=1e-6)
|
|
#
|
|
# self.up = nn.Sequential(
|
|
# nn.Conv2d(dim, sr_ratio * sr_ratio * dim, kernel_size=3, stride=1, padding=1, groups=dim),
|
|
# nn.PixelShuffle(upscale_factor=sr_ratio)
|
|
# )
|
|
# self.up_norm = nn.LayerNorm(dim, eps=1e-6)
|
|
#
|
|
# self.proj = nn.Conv2d(dim, dim, kernel_size=1)
|
|
#
|
|
# def forward(self, x):
|
|
# B, C, H, W = x.shape
|
|
# N = H * W
|
|
#
|
|
# q = self.q(x).reshape(B, self.num_heads, C // self.num_heads, N).permute(0, 1, 3, 2)
|
|
#
|
|
# if self.sr_ratio > 1:
|
|
# x = self.sr(x).reshape(B, C, -1).permute(0, 2, 1)
|
|
# x = self.sr_norm(x)
|
|
# x = x.permute(0, 2, 1).reshape(B, C, H // self.sr_ratio, W // self.sr_ratio)
|
|
# else:
|
|
# x = x.reshape(B, C, N).permute(0, 2, 1)
|
|
#
|
|
# kv = self.kv(x).reshape(B, 2, self.num_heads, C // self.num_heads, -1).permute(1, 0, 2, 4, 3)
|
|
# k, v = kv[0], kv[1]
|
|
#
|
|
# attn = (q @ k.transpose(-2, -1)) * self.scale
|
|
# attn = attn.softmax(dim=-1)
|
|
#
|
|
# x = (attn @ v).transpose(1, 2).reshape(B, C, H, W)
|
|
#
|
|
# identity = v.transpose(-1, -2).reshape(B, C, H // self.sr_ratio, W // self.sr_ratio)
|
|
# identity = self.up(identity)
|
|
# identity = identity.flatten(2).transpose(1, 2).reshape(B, C, H, W)
|
|
# x = self.proj(x + identity)
|
|
# return x
|
|
|
|
class EffcirntMutilSelfAttention(nn.Module):
|
|
def __init__(self,
|
|
dim,
|
|
num_heads=8,
|
|
qkv_bias=False,
|
|
qk_scale=None,
|
|
attn_drop=0.,
|
|
proj_drop=0.,
|
|
sr_ratio=1,
|
|
apply_transform=False):
|
|
super().__init__()
|
|
self.num_heads = num_heads
|
|
head_dim = dim // num_heads
|
|
self.scale = qk_scale or head_dim ** -0.5
|
|
|
|
self.q = nn.Conv2d(dim, dim, kernel_size=1, bias=qkv_bias)
|
|
self.kv = nn.Conv2d(dim, dim * 2, kernel_size=1, bias=qkv_bias)
|
|
self.attn_drop = nn.Dropout(attn_drop)
|
|
self.proj = nn.Conv2d(dim, dim, kernel_size=1)
|
|
self.proj_drop = nn.Dropout(proj_drop)
|
|
|
|
self.sr_ratio = sr_ratio
|
|
if sr_ratio > 1:
|
|
self.sr = nn.Conv2d(dim, dim, kernel_size=sr_ratio + 1, stride=sr_ratio, padding=sr_ratio // 2, groups=dim)
|
|
self.sr_norm = nn.LayerNorm(dim)
|
|
|
|
self.apply_transform = apply_transform and num_heads > 1
|
|
if self.apply_transform:
|
|
self.transform_conv = nn.Conv2d(self.num_heads, self.num_heads, kernel_size=1, stride=1)
|
|
self.transform_norm = nn.InstanceNorm2d(self.num_heads)
|
|
|
|
def forward(self, x):
|
|
B, C, H, W = x.shape
|
|
q = self.q(x).reshape(B, self.num_heads, C // self.num_heads, H * W).permute(0, 1, 3, 2)
|
|
if self.sr_ratio > 1:
|
|
x_ = self.sr(x).reshape(B, C, -1).permute(0, 2, 1)
|
|
x_ = self.sr_norm(x_)
|
|
kv = self.kv(x_).reshape(B, -1, 2, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
|
|
else:
|
|
kv = self.kv(x).reshape(B, 2, self.num_heads, C // self.num_heads, H * W).permute(1, 0, 2, 4, 3)
|
|
k, v = kv[0], kv[1]
|
|
|
|
attn = (q @ k.transpose(-2, -1)) * self.scale
|
|
if self.apply_transform:
|
|
attn = self.transform_conv(attn)
|
|
attn = attn.softmax(dim=-1)
|
|
attn = self.transform_norm(attn)
|
|
else:
|
|
attn = attn.softmax(dim=-1)
|
|
|
|
attn = self.attn_drop(attn)
|
|
x = (attn @ v).transpose(2, 3).reshape(B, self.num_heads * (C // self.num_heads), H, W)
|
|
x = self.proj(x)
|
|
x = self.proj_drop(x)
|
|
return x
|
|
|
|
|
|
class GlobalLocalAttention(nn.Module):
|
|
def __init__(self, dim=256, num_heads=16, qkv_bias=False, window_size=8, relative_pos_embedding=True):
|
|
super(GlobalLocalAttention, self).__init__()
|
|
self.local1 = ImprovedLocalAttention(dim)
|
|
# self.local2 = ImprovedLocalAttention(dim)
|
|
self.global_attention = EffcirntMutilSelfAttention(dim, num_heads, qkv_bias, window_size, relative_pos_embedding)
|
|
|
|
def forward(self, x):
|
|
# Combining local and global attention
|
|
local = self.local1(x)
|
|
global_attn = self.global_attention(x)
|
|
return local + global_attn
|
|
|
|
|
|
# Testing the model with a random tensor
|
|
gl_attention = GlobalLocalAttention(dim=256, num_heads=16, qkv_bias=False, window_size=8, relative_pos_embedding=True)
|
|
x = torch.randn(1, 256, 64, 64)
|
|
output = gl_attention(x)
|
|
print(output.shape) # Output should be (1, 256, 64, 64)
|
|
|