181 lines
6.2 KiB
Python
181 lines
6.2 KiB
Python
import torch
|
|
from torch import nn
|
|
import torch.nn.init as init
|
|
import torch.nn.functional as F
|
|
import torchvision.models as models
|
|
from PIL import Image
|
|
import torchvision.transforms as transforms
|
|
#from network import GeM as gem
|
|
import torch.nn.functional as F
|
|
class channelAttention(nn.Module):
|
|
def __init__(self, channel, reduction=16):
|
|
super(channelAttention, self).__init__()
|
|
self.Maxpooling = nn.AdaptiveMaxPool2d(1)
|
|
self.Avepooling = nn.AdaptiveAvgPool2d(1)
|
|
self.ca = nn.Sequential()
|
|
self.ca.add_module('conv1',nn.Conv2d(channel, channel//reduction, 1, bias=False))
|
|
self.ca.add_module('Relu', nn.ReLU())
|
|
self.ca.add_module('conv2',nn.Conv2d(channel//reduction, channel, 1, bias=False))
|
|
self.sigmod = nn.Sigmoid()
|
|
|
|
def forward(self, x):
|
|
M_out = self.Maxpooling(x)
|
|
A_out = self.Avepooling(x)
|
|
M_out = self.ca(M_out)
|
|
A_out = self.ca(A_out)
|
|
out = self.sigmod(M_out+A_out)
|
|
return out
|
|
|
|
class SpatialAttention(nn.Module):
|
|
def __init__(self, kernel_size=7):
|
|
super().__init__()
|
|
self.conv = nn.Conv2d(in_channels=2, out_channels=1, kernel_size=kernel_size, padding=kernel_size // 2)
|
|
self.sigmoid = nn.Sigmoid()
|
|
|
|
def forward(self, x):
|
|
max_result, _ = torch.max(x, dim=1, keepdim=True)
|
|
avg_result = torch.mean(x, dim=1, keepdim=True)
|
|
result = torch.cat([max_result, avg_result], dim=1)
|
|
output = self.conv(result)
|
|
output = self.sigmoid(output)
|
|
return output
|
|
class CBAM(nn.Module):
|
|
def __init__(self, channel=512, reduction=16, kernel_size=7):
|
|
super().__init__()
|
|
self.ca = channelAttention(channel, reduction)
|
|
self.sa = SpatialAttention(kernel_size)
|
|
|
|
def init_weights(self):
|
|
for m in self.modules():#权重初始化
|
|
if isinstance(m, nn.Conv2d):
|
|
init.kaiming_normal_(m.weight, mode='fan_out')
|
|
if m.bias is not None:
|
|
init.constant_(m.bias, 0)
|
|
elif isinstance(m, nn.BatchNorm2d):
|
|
init.constant_(m.weight, 1)
|
|
init.constant_(m.bias, 0)
|
|
elif isinstance(m, nn.Linear):
|
|
init.normal_(m.weight, std=0.001)
|
|
if m.bias is not None:
|
|
init.constant_(m.bias, 0)
|
|
|
|
def forward(self, x):
|
|
# b,c_,_ = x.size()
|
|
# residual = x
|
|
out = x*self.ca(x)
|
|
out = out*self.sa(out)
|
|
return out
|
|
|
|
class GeM(nn.Module):
|
|
def __init__(self, p=3, eps=1e-6):
|
|
super(GeM, self).__init__()
|
|
self.p = nn.Parameter(torch.ones(1) * p)
|
|
self.eps = eps
|
|
|
|
def forward(self, x):
|
|
return self.gem(x, p=self.p, eps=self.eps)
|
|
|
|
def gem(self, x, p=3, eps=1e-6):
|
|
#return F.avg_pool2d(x.clamp(min=eps).pow(p), (x.size(-2), x.size(-1))).pow(1. / p)
|
|
return F.avg_pool2d(x.clamp(min=eps).pow(p), (7, 7)).pow(1. / p)
|
|
|
|
def __repr__(self):
|
|
return self.__class__.__name__ + \
|
|
'(' + 'p=' + '{:.4f}'.format(self.p.data.tolist()[0]) + \
|
|
', ' + 'eps=' + str(self.eps) + ')'
|
|
|
|
class ResnetFpn(nn.Module):
|
|
def __init__(self):
|
|
super(ResnetFpn, self).__init__()
|
|
self.model = models.resnet50()
|
|
self.conv1 = nn.Conv2d(in_channels=2048, out_channels=256, kernel_size=1, stride=1, padding=0)
|
|
self.conv2 = nn.Conv2d(1024, 256, 1, 1, 0)
|
|
self.conv3 = nn.Conv2d(512, 256, 1, 1, 0)
|
|
self.conv4 = nn.Conv2d(256, 256, 1, 1, 0)
|
|
self.fpn_convs = nn.Conv2d(256, 256, 3, 1, 1)
|
|
self.pool = nn.AvgPool2d(7, 7, padding=2)
|
|
#self.gem = GeM()
|
|
#self.in_channel = 64
|
|
self.cbam_layer1 = CBAM(256)
|
|
self.cbam_layer2 = CBAM(512)
|
|
self.cbam_layer3 = CBAM(1024)
|
|
self.cbam_layer4 = CBAM(2048)
|
|
self.fc = nn.Linear(in_features=20736, out_features=2048)
|
|
self.fc1 = nn.Linear(2048, 1024)
|
|
self.fc2 = nn.Linear(1024, 512)
|
|
self.fc3 = nn.Linear(512, 128)
|
|
|
|
def forward(self, x):
|
|
x = self.model.conv1(x)
|
|
x = self.model.bn1(x)
|
|
x = self.model.relu(x)
|
|
x = self.model.maxpool(x)
|
|
|
|
layer1 = self.model.layer1(x)
|
|
layer1 = self.cbam_layer1(layer1)
|
|
#print('layer1 >>> {}'.format(layer1.shape))
|
|
|
|
layer2 = self.model.layer2(layer1)
|
|
layer2 = self.cbam_layer2(layer2)
|
|
#print('layer2 >>> {}'.format(layer2.shape))
|
|
|
|
layer3 = self.model.layer3(layer2)
|
|
layer3 = self.cbam_layer3(layer3)
|
|
#print('layer3 >>> {}'.format(layer3.shape))
|
|
|
|
layer4 = self.model.layer4(layer3) # channel 256 512 1024 2048
|
|
layer4 = self.cbam_layer4(layer4)
|
|
#print('layer4 >>> {}'.format(layer4.shape))
|
|
|
|
P5 = self.conv1(layer4)
|
|
P4_ = self.conv2(layer3)
|
|
P3_ = self.conv3(layer2)
|
|
P2_ = self.conv4(layer1)
|
|
|
|
size4 = P4_.shape[2:]
|
|
size3 = P3_.shape[2:]
|
|
size2 = P2_.shape[2:]
|
|
|
|
P4 = P4_ + F.interpolate(P5, size=size4, mode='nearest')
|
|
P3 = P3_ + F.interpolate(P4, size=size3, mode='nearest')
|
|
P2 = P2_ + F.interpolate(P3, size=size2, mode='nearest')
|
|
|
|
P5 = self.fpn_convs(P5)
|
|
P4 = self.fpn_convs(P4)
|
|
P3 = self.fpn_convs(P3)
|
|
P2 = self.fpn_convs(P2)
|
|
|
|
output = self.pool(P2)
|
|
#output = self.gem(P2)
|
|
|
|
#input_dim = len(output.view(-1))
|
|
|
|
#output = output.view(output.size(0), -1)
|
|
output = output.contiguous().view(output.size(0), -1)
|
|
|
|
output = self.fc(output)
|
|
output = self.fc1(output)
|
|
output = self.fc2(output)
|
|
output = self.fc3(output)
|
|
return output
|
|
|
|
if __name__ == '__main__':
|
|
img_path = '600.jpg'
|
|
img = Image.open('600.jpg')
|
|
# if img.mode != 'L':
|
|
# img = img.convert('L')
|
|
#img = img.resize((256, 256))
|
|
transform = transforms.Compose([transforms.Resize((256,256)),
|
|
transforms.ToTensor()])
|
|
img = transform(img)
|
|
img = img.cuda()
|
|
|
|
# from torchsummary import summary
|
|
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
|
|
model = ResnetFpn().to(device)
|
|
model.eval()
|
|
img = torch.unsqueeze(img, dim=0).float()
|
|
# images, targets = model.transform(images, targets=None)
|
|
result = model(img)
|
|
#print('result >>> {} >>{}'.format(result, result.size()))
|