Merge pull request #17 from BloodAxe/develop

Release 0.1.2

Author: BloodAxe

README.md

@@ -6,12 +6,17 @@
 
 A `pytorch-toolbelt` is a Python library with a set of bells and whistles for PyTorch for fast R&D prototyping and Kaggle farming:
 
+## What's inside
+
 * Easy model building using flexible encoder-decoder architecture.
-* Modules: CoordConv, SCSE, Hypercolumn, Depthwise separable convolution and more
+* Modules: CoordConv, SCSE, Hypercolumn, Depthwise separable convolution and more.
 * GPU-friendly test-time augmentation TTA for segmentation and classification
 * GPU-friendly inference on huge (5000x5000) images
 * Every-day common routines (fix/restore random seed, filesystem utils, metrics)
-* Fancy losses: Focal, Lovasz, Jaccard and Dice losses, Wing Loss
+* Losses: BinaryFocalLoss, Focal, ReducedFocal, Lovasz, Jaccard and Dice losses, Wing Loss and more.
+* Extras for [Catalyst](https://github.com/catalyst-team/catalyst) library (Visualization of batch predictions, additional metrics) 
+
+Showcase: [Catalyst, Albumentations, Pytorch Toolbelt example: Semantic Segmentation @ CamVid](https://colab.research.google.com/drive/1OUPJYU7TzH5Vz1si6FBkooackuIlzaGr#scrollTo=GUWuiO5K3aUm)
 
 # Why
 
@@ -119,4 +124,5 @@ merged_mask = tiler.crop_to_orignal_size(merged_mask)
 
 ## Advanced examples
 
-1. [Inria Sattelite Segmentation](https://github.com/BloodAxe/Catalyst-Inria-Segmentation-Example)
+1. [Inria Sattelite Segmentation](https://github.com/BloodAxe/Catalyst-Inria-Segmentation-Example)
+1. [CamVid Semantic Segmentation](https://github.com/BloodAxe/Catalyst-CamVid-Segmentation-Example)

pytorch_toolbelt/__init__.py

@@ -1,3 +1,3 @@
 from __future__ import absolute_import
 
-__version__ = '0.1.1'
+__version__ = '0.1.2'

pytorch_toolbelt/inference/tta.py

@@ -7,6 +7,7 @@
 from typing import Tuple, List
 
 from torch import Tensor, nn
+from torch.nn.functional import interpolate
 
 from . import functional as F
 
@@ -236,11 +237,11 @@ def forward(self, input: Tensor) -> Tensor:
 
         for scale in self.scale_levels:
             dst_size = int(h * scale), int(w * scale)
-            input_scaled = F.interpolate(input, dst_size, mode='bilinear',
-                                         align_corners=True)
+            input_scaled = interpolate(input, dst_size, mode='bilinear',
+                                       align_corners=True)
             output_scaled = self.model(input_scaled)
-            output_scaled = F.interpolate(output_scaled, out_size,
-                                          mode='bilinear', align_corners=True)
+            output_scaled = interpolate(output_scaled, out_size,
+                                        mode='bilinear', align_corners=True)
             output += output_scaled
 
         return output / (1 + len(self.scale_levels))

pytorch_toolbelt/losses/focal.py

@@ -1,10 +1,8 @@
 from functools import partial
 
-import torch
-from torch import nn
+from torch.nn.modules.loss import _Loss
 
 from .functional import sigmoid_focal_loss, reduced_focal_loss
-from torch.nn.modules.loss import _Loss
 
 __all__ = ['BinaryFocalLoss', 'FocalLoss']
 
@@ -57,52 +55,18 @@ def forward(self, label_input, label_target):
         """
         num_classes = label_input.size(1)
         loss = 0
-        label_target = label_target.view(-1)
-        label_input = label_input.view(-1, num_classes)
 
         # Filter anchors with -1 label from loss computation
         if self.ignore is not None:
             not_ignored = label_target != self.ignore
 
         for cls in range(num_classes):
-            cls_label_target = (label_target == (cls + 0)).long()
-            cls_label_input = label_input[..., cls]
+            cls_label_target = (label_target == cls).long()
+            cls_label_input = label_input[:, cls, ...]
 
             if self.ignore is not None:
                 cls_label_target = cls_label_target[not_ignored]
                 cls_label_input = cls_label_input[not_ignored]
 
             loss += sigmoid_focal_loss(cls_label_input, cls_label_target, gamma=self.gamma, alpha=self.alpha)
         return loss
-
-# Needs testing
-# class SoftmaxFocalLoss(nn.Module):
-#     def __init__(self, gamma=2, eps=1e-7):
-#         super(SoftmaxFocalLoss, self).__init__()
-#         self.gamma = gamma
-#         self.eps = eps
-#
-#     @staticmethod
-#     def _one_hot(index, classes):
-#         size = index.size() + (classes,)
-#         view = index.size() + (1,)
-#
-#         mask = torch.Tensor(*size).fill_(0)
-#         index = index.view(*view)
-#         ones = 1.
-#
-#         if isinstance(index, Variable):
-#             ones = Variable(torch.Tensor(index.size()).fill_(1))
-#             mask = Variable(mask, volatile=index.volatile)
-#
-#         return mask.scatter_(1, index, ones)
-#
-#     def forward(self, input, target):
-#         y = one_hot(target, input.size(-1))
-#         logit = F.softmax(input, dim=-1)
-#         logit = logit.clamp(self.eps, 1. - self.eps)
-#
-#         loss = -1 * y * torch.log(logit)  # cross entropy
-#         loss = loss * (1 - logit) ** self.gamma  # focal loss
-#
-#         return loss.sum()