| import torch | |
| import torch.nn as nn | |
| import torch.nn.functional as F | |
| from backbones.upsample_head import SimpleUpsampleHead | |
| class SimpleDetectionDecoder(nn.Module): | |
| def __init__(self, feature_channel=256): | |
| nn.Module.__init__(self) | |
| self.feature_channel = feature_channel | |
| self.head_layer = self.create_head_layer() | |
| self.pred_layers = nn.ModuleDict(self.create_pred_layers()) | |
| def create_head_layer(self): | |
| return SimpleUpsampleHead( | |
| self.feature_channel, | |
| [self.feature_channel, self.feature_channel // 2, self.feature_channel // 4] | |
| ) | |
| def create_pred_layer(self, channels): | |
| return nn.Sequential( | |
| nn.Conv2d(self.feature_channel // 4, channels, kernel_size=1, stride=1, padding=0, bias=False), | |
| ) | |
| def create_pred_layers(self): | |
| return {} | |
| def postprocess_pred(self, pred): | |
| return pred | |
| def calculate_losses(self, preds, label): | |
| raise NotImplementedError() | |
| def forward(self, input, label, meta, train): | |
| feature = self.head_layer(input) | |
| pred = {} | |
| for name, pred_layer in self.pred_layers.items(): | |
| pred[name] = pred_layer(feature) | |
| if train: | |
| losses = self.calculate_losses(pred, label) | |
| pred = self.postprocess_pred(pred) | |
| loss = sum(losses.values()) | |
| return loss, pred, losses | |
| else: | |
| pred = self.postprocess_pred(pred) | |
| return pred | |
| class SimpleSegDecoder(SimpleDetectionDecoder): | |
| def create_pred_layers(self): | |
| return { | |
| 'heatmap': self.create_pred_layer(1) | |
| } | |
| def postprocess_pred(self, pred): | |
| pred['heatmap'] = F.sigmoid(pred['heatmap']) | |
| return pred | |
| def calculate_losses(self, pred, label): | |
| heatmap = label['heatmap'] | |
| heatmap_weight = label['heatmap_weight'] | |
| heatmap_pred = pred['heatmap'] | |
| heatmap_loss = F.binary_cross_entropy_with_logits(heatmap_pred, heatmap, reduction='none') | |
| heatmap_loss = (heatmap_loss * heatmap_weight).mean(dim=(1, 2, 3)) | |
| return { | |
| 'heatmap_loss': heatmap_loss, | |
| } | |
| class SimpleEASTDecoder(SimpleDetectionDecoder): | |
| def __init__(self, feature_channels=256, densebox_ratio=1000.0, densebox_rescale_factor=512): | |
| SimpleDetectionDecoder.__init__(self, feature_channels) | |
| self.densebox_ratio = densebox_ratio | |
| self.densebox_rescale_factor = densebox_rescale_factor | |
| def create_pred_layers(self): | |
| return { | |
| 'heatmap': self.create_pred_layer(1), | |
| 'densebox': self.create_pred_layer(8), | |
| } | |
| def postprocess_pred(self, pred): | |
| pred['heatmap'] = F.sigmoid(pred['heatmap']) | |
| pred['densebox'] = pred['densebox'] * self.densebox_rescale_factor | |
| return pred | |
| def calculate_losses(self, pred, label): | |
| heatmap = label['heatmap'] | |
| heatmap_weight = label['heatmap_weight'] | |
| densebox = label['densebox'] / self.densebox_rescale_factor | |
| densebox_weight = label['densebox_weight'] | |
| heatmap_pred = pred['heatmap'] | |
| densebox_pred = pred['densebox'] | |
| heatmap_loss = F.binary_cross_entropy_with_logits(heatmap_pred, heatmap, reduction='none') | |
| heatmap_loss = (heatmap_loss * heatmap_weight).mean(dim=(1, 2, 3)) | |
| densebox_loss = F.mse_loss(densebox_pred, densebox, reduction='none') | |
| densebox_loss = (densebox_loss * densebox_weight).mean(dim=(1, 2, 3)) * self.densebox_ratio | |
| return { | |
| 'heatmap_loss': heatmap_loss, | |
| 'densebox_loss': densebox_loss, | |
| } | |
| class SimpleTextsnakeDecoder(SimpleDetectionDecoder): | |
| def __init__(self, feature_channels=256, radius_ratio=10.0): | |
| SimpleDetectionDecoder.__init__(self, feature_channels) | |
| self.radius_ratio = radius_ratio | |
| def create_pred_layers(self): | |
| return { | |
| 'heatmap': self.create_pred_layer(1), | |
| 'radius': self.create_pred_layer(1), | |
| } | |
| def postprocess_pred(self, pred): | |
| pred['heatmap'] = F.sigmoid(pred['heatmap']) | |
| pred['radius'] = torch.exp(pred['radius']) | |
| return pred | |
| def calculate_losses(self, pred, label): | |
| heatmap = label['heatmap'] | |
| heatmap_weight = label['heatmap_weight'] | |
| radius = torch.log(label['radius'] + 1) | |
| radius_weight = label['radius_weight'] | |
| heatmap_pred = pred['heatmap'] | |
| radius_pred = pred['radius'] | |
| heatmap_loss = F.binary_cross_entropy_with_logits(heatmap_pred, heatmap, reduction='none') | |
| heatmap_loss = (heatmap_loss * heatmap_weight).mean(dim=(1, 2, 3)) | |
| radius_loss = F.smooth_l1_loss(radius_pred, radius, reduction='none') | |
| radius_loss = (radius_loss * radius_weight).mean(dim=(1, 2, 3)) * self.radius_ratio | |
| return { | |
| 'heatmap_loss': heatmap_loss, | |
| 'radius_loss': radius_loss, | |
| } | |
| class SimpleMSRDecoder(SimpleDetectionDecoder): | |
| def __init__(self, feature_channels=256, offset_ratio=1000.0, offset_rescale_factor=512): | |
| SimpleDetectionDecoder.__init__(self, feature_channels) | |
| self.offset_ratio = offset_ratio | |
| self.offset_rescale_factor = offset_rescale_factor | |
| def create_pred_layers(self): | |
| return { | |
| 'heatmap': self.create_pred_layer(1), | |
| 'offset': self.create_pred_layer(2), | |
| } | |
| def postprocess_pred(self, pred): | |
| pred['heatmap'] = F.sigmoid(pred['heatmap']) | |
| pred['offset'] = pred['offset'] * self.offset_rescale_factor | |
| return pred | |
| def calculate_losses(self, pred, label): | |
| heatmap = label['heatmap'] | |
| heatmap_weight = label['heatmap_weight'] | |
| offset = label['offset'] / self.offset_rescale_factor | |
| offset_weight = label['offset_weight'] | |
| heatmap_pred = pred['heatmap'] | |
| offset_pred = pred['offset'] | |
| heatmap_loss = F.binary_cross_entropy_with_logits(heatmap_pred, heatmap, reduction='none') | |
| heatmap_loss = (heatmap_loss * heatmap_weight).mean(dim=(1, 2, 3)) | |
| offset_loss = F.mse_loss(offset_pred, offset, reduction='none') | |
| offset_loss = (offset_loss * offset_weight).mean(dim=(1, 2, 3)) * self.offset_ratio | |
| return { | |
| 'heatmap_loss': heatmap_loss, | |
| 'offset_loss': offset_loss, | |
| } | |