import torch from numpy import ceil from torch import nn, clamp from torch.functional import F class DiscriminativeNet(nn.Module): def __init__(self): super(DiscriminativeNet, self).__init__() self.conv1 = nn.Conv2d(in_channels=3, out_channels=8, kernel_size=5, stride=2, padding=1) self.conv2 = nn.Conv2d(in_channels=8, out_channels=16, kernel_size=5, stride=2, padding=2) self.conv3 = nn.Conv2d(in_channels=16, out_channels=32, kernel_size=5, stride=2, padding=2) self.conv4 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=5, stride=2, padding=2) self.conv5 = nn.Conv2d(in_channels=64, out_channels=128, kernel_size=5, stride=1, padding=2) self.conv6 = nn.Conv2d(in_channels=128, out_channels=128, kernel_size=5, stride=1, padding=2) self.conv_attention = nn.Conv2d(in_channels=128, out_channels=1, kernel_size=5, stride=1, padding=2, bias=False) self.conv7 = nn.Conv2d(in_channels=128, out_channels=64, kernel_size=5, stride=4, padding=2) self.conv8 = nn.Conv2d(in_channels=64, out_channels=64, kernel_size=5, stride=4, padding=2) self.conv9 = nn.Conv2d(in_channels=64, out_channels=32, kernel_size=5, stride=4, padding=2) self.fc1 = nn.Linear(32, 1) # You need to adjust the input dimension here depending on your input size self.fc2 = nn.Linear(1, 1) def forward(self, x): x1 = F.leaky_relu(self.conv1(x)) x2 = F.leaky_relu(self.conv2(x1)) x3 = F.leaky_relu(self.conv3(x2)) x4 = F.leaky_relu(self.conv4(x3)) x5 = F.leaky_relu(self.conv5(x4)) x6 = F.leaky_relu(self.conv6(x5)) attention_map = self.conv_attention(x6) x7 = F.leaky_relu(self.conv7(attention_map * x6)) x8 = F.leaky_relu(self.conv8(x7)) x9 = F.leaky_relu(self.conv9(x8)) x9 = x9.view(x9.size(0), -1) # flatten the tensor fc1 = self.fc1(x9) fc_raw = self.fc2(fc1) fc_out = F.sigmoid(fc_raw) # Ensure fc_out is not exactly 0 or 1 for stability of log operation in loss fc_out = clamp(fc_out, min=1e-7, max=1 - 1e-7) ret = { "fc_out" : fc_out, "attention_map": attention_map, "fc_raw" : fc_raw } return ret def loss(self, real_clean, generated_clean, attention_map): """ :param real_clean: :param generated_clean: :param attention_map: This is the final attention map from the generator. :return: """ batch_size, _, image_h, image_w = real_clean.size() attention_map = F.interpolate(attention_map[-1], size=(int(ceil(image_h/16)), int(ceil(image_w/16)))) zeros_mask = torch.zeros([batch_size, 1, int(ceil(image_h/16)), int(ceil(image_w/16))], dtype=attention_map.dtype).to(attention_map.device) # Inference function ret = self.forward(real_clean) fc_out_o, attention_mask_o, fc2_o = ret["fc_out"], ret["attention_map"], ret["fc_raw"] ret = self.forward(generated_clean) fc_out_r, attention_mask_r, fc2_r = ret["fc_out"], ret["attention_map"], ret["fc_raw"] l_map = F.mse_loss(attention_map, attention_mask_o) + \ F.mse_loss(attention_mask_r, zeros_mask) entropy_loss = -torch.log(fc_out_r) - torch.log(-torch.sub(fc_out_o, 1.0)) entropy_loss = torch.mean(entropy_loss) loss = entropy_loss + 0.05 * l_map return loss.to(dtype=attention_map.dtype) if __name__ == "__main__": import torch from torchinfo import summary torch.set_default_tensor_type(torch.FloatTensor) generator = DiscriminativeNet(960,540) batch_size = 1 summary(generator, input_size=(batch_size, 3, 960,540))