From 18b3db859a493d7b425b9388c9f95ce2ca2a4ee8 Mon Sep 17 00:00:00 2001
From: Emil Zakirov <bonlimezak@gmail.com>
Date: Wed, 29 Apr 2020 20:30:16 +0300
Subject: [PATCH 01/54] upd version

---
 pytorch_tools/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pytorch_tools/__init__.py b/pytorch_tools/__init__.py
index 85f6dc8..b12314a 100644
--- a/pytorch_tools/__init__.py
+++ b/pytorch_tools/__init__.py
@@ -1,4 +1,4 @@
-__version__ = "0.1.4"
+__version__ = "0.1.5"
 
 from . import fit_wrapper
 from . import losses

From 1ed4dafddd42818b1ebd272904719e4e112d6854 Mon Sep 17 00:00:00 2001
From: Emil Zakirov <bonlimezak@gmail.com>
Date: Wed, 6 May 2020 18:15:59 +0300
Subject: [PATCH 02/54] ...

---
 pytorch_tools/__init__.py                   |   1 +
 pytorch_tools/detection_models/__init__.py  |   1 +
 pytorch_tools/detection_models/retinanet.py |  26 ++-
 pytorch_tools/utils/box.py                  | 168 ++++++++++++++++++++
 4 files changed, 188 insertions(+), 8 deletions(-)
 create mode 100644 pytorch_tools/utils/box.py

diff --git a/pytorch_tools/__init__.py b/pytorch_tools/__init__.py
index b12314a..651659b 100644
--- a/pytorch_tools/__init__.py
+++ b/pytorch_tools/__init__.py
@@ -9,3 +9,4 @@
 from . import segmentation_models
 from . import tta_wrapper
 from . import utils
+from . import detection_models
diff --git a/pytorch_tools/detection_models/__init__.py b/pytorch_tools/detection_models/__init__.py
index e69de29..7c7fc59 100644
--- a/pytorch_tools/detection_models/__init__.py
+++ b/pytorch_tools/detection_models/__init__.py
@@ -0,0 +1 @@
+from .retinanet import RetinaNet
\ No newline at end of file
diff --git a/pytorch_tools/detection_models/retinanet.py b/pytorch_tools/detection_models/retinanet.py
index 5ebc360..e64a12c 100644
--- a/pytorch_tools/detection_models/retinanet.py
+++ b/pytorch_tools/detection_models/retinanet.py
@@ -1,6 +1,6 @@
-# import torch
+import torch
 import torch.nn as nn
-import torch.nn.functional as F
+# import torch.nn.functional as F
 from pytorch_tools.modules.fpn import FPN
 # from pytorch_tools.modules.bifpn import BiFPN
 from pytorch_tools.modules import bn_from_name
@@ -43,7 +43,8 @@ def make_head(out_size):
             for _ in range(4):
                 # some implementations don't use BN here but I think it's needed
                 # TODO: test how it affects results
-                layers += [nn.Conv2d(256, 256, 3, padding=1), norm_layer(256, activation=norm_act)]
+                # upd. removed norm_layer. maybe change to group_norm later
+                layers += [nn.Conv2d(256, 256, 3, padding=1)] # norm_layer(256, activation=norm_act)
                 # layers += [nn.Conv2d(256, 256, 3, padding=1), nn.ReLU()]
 
             layers += [nn.Conv2d(256, out_size, 3, padding=1)]
@@ -55,19 +56,28 @@ def make_head(out_size):
 
         self.cls_head = make_head(num_classes * anchors)
         self.box_head = make_head(4 * anchors)
+        self.num_classes = num_classes
 
     def forward(self, x):
         # don't use p2 and p1
         p5, p4, p3, _, _ = self.encoder(x)
         # enhance features
         p5, p4, p3 = self.fpn([p5, p4, p3])
-        # coarsers FPN levels
+        # coarser FPN levels
         p6 = self.pyramid6(p5)
-        p7 = self.pyramid7(F.relu(p6))
-        features = [p7, p6, p5, p4, p3]
+        p7 = self.pyramid7(p6.relu())
+        # want features from lowest OS to highest to align with `generate_anchors_boxes` function 
+        features = [p3, p4, p5, p6, p7]
         # TODO: (18.03.20) TF implementation has additional BN here before class/box outputs
-        class_outputs = [self.cls_head(f) for f in features]
-        box_outputs = [self.box_head(f) for f in features]
+        class_outputs = []
+        box_outputs = []
+        for f in features:
+            cls_anchor = self.cls_head(f).transpose(1, 3).contiguous().view(x.shape[0], -1, self.num_classes)
+            box_anchor = self.box_head(f).transpose(1, 3).contiguous().view(x.shape[0], -1, 4)
+            class_outputs.append(cls_anchor)
+            box_outputs.append(box_anchor)
+        class_outputs = torch.cat(class_outputs, 1)
+        box_outputs = torch.cat(box_outputs, 1)
         return class_outputs, box_outputs
         
 
diff --git a/pytorch_tools/utils/box.py b/pytorch_tools/utils/box.py
new file mode 100644
index 0000000..172fcf1
--- /dev/null
+++ b/pytorch_tools/utils/box.py
@@ -0,0 +1,168 @@
+"""Various functions to help with bboxes"""
+import torch
+import numpy as np
+
+def box2delta(boxes, anchors):
+    """Convert boxes to deltas from anchors. Boxes are expected in 'ltrb' format
+    Args:
+        boxes (torch.Tensor): shape [N, 4]
+        anchors (torch.Tensor): shape [N, 4]
+    Returns:
+        deltas (torch.Tensor): shape [N, 4]. offset_x, offset_y, scale_x, scale_y
+    """
+
+    anchors_wh = anchors[:, 2:] - anchors[:, :2] + 1
+    anchors_ctr = anchors[:, :2] + 0.5 * anchors_wh
+    boxes_wh = boxes[:, 2:] - boxes[:, :2] + 1
+    boxes_ctr = boxes[:, :2] + 0.5 * boxes_wh
+    offset_delta = (boxes_ctr - anchors_ctr) / anchors_wh
+    scale_delta = torch.log(boxes_wh / anchors_wh)
+    return torch.cat([offset_delta, scale_delta], 1)
+
+
+def delta2box(deltas, anchors):
+    """Convert anchors to boxes using deltas. Boxes are expected in 'ltrb' format
+    Args:
+        deltas (torch.Tensor): shape [N, 4]. 
+        anchors (torch.Tensor): shape [N, 4]
+    Returns:
+        bboxes (torch.Tensor): bboxes obtained from anchors by regression [N, 4]
+    """
+
+    anchors_wh = anchors[:, 2:] - anchors[:, :2] + 1
+    ctr = anchors[:, :2] + 0.5 * anchors_wh
+    pred_ctr = deltas[:, :2] * anchors_wh + ctr
+    pred_wh = torch.exp(deltas[:, 2:]) * anchors_wh
+
+    return torch.cat([pred_ctr - 0.5 * pred_wh, pred_ctr + 0.5 * pred_wh - 1], 1)
+
+# implementation from https://github.com/kuangliu/torchcv/blob/master/torchcv/utils/box.py
+# with slight modifications
+def box_iou(boxes1, boxes2):
+    """
+    Return intersection-over-union (Jaccard index) of boxes.
+    Both sets of boxes are expected to be in `ltrb`: (x1, y1, x2, y2) format.
+    Arguments:
+        boxes1 (Tensor[N, 4])
+        boxes2 (Tensor[M, 4])
+    Returns:
+        iou (Tensor[N, M]): the NxM matrix containing the pairwise
+            IoU values for every element in boxes1 and boxes2
+    """
+    area1 = (boxes1[:, 2] - boxes1[:, 0]) * (boxes1[:, 3] - boxes1[:, 1])
+    area2 = (boxes2[:, 2] - boxes2[:, 0]) * (boxes2[:, 3] - boxes2[:, 1])
+
+    lt = torch.max(boxes1[:, None, :2], boxes2[:, :2])  # [N,M,2]
+    rb = torch.min(boxes1[:, None, 2:], boxes2[:, 2:])  # [N,M,2]
+
+    wh = (rb - lt).clamp(min=0)  # [N,M,2]
+    inter = wh[:, :, 0] * wh[:, :, 1]  # [N,M]
+
+    iou = inter / (area1[:, None] + area2 - inter)
+    return iou
+
+
+# based on https://github.com/NVIDIA/retinanet-examples/
+# and on https://github.com/google/automl/ 
+def generate_anchors_boxes(
+    image_size, 
+    num_scales=3,
+    aspect_ratios=(1.0, 2.0, 0.5),
+    pyramid_levels=[3, 4, 5, 6, 7],
+    anchor_scale=4,
+):
+    """Generates multiscale anchor boxes
+    Minimum object size which could be detected is anchor_scale * 2**pyramid_levels[0]. By default it's 32px
+    Maximum object size which could be detected is anchor_scale * 2**pyramid_levels[-1]. By default it's 512px 
+    
+    Args: 
+        image_size (int or (int, int)): shape of the image
+        num_scales (int): integer number representing intermediate scales added on each level. For instances, 
+            num_scales=3 adds three additional anchor scales [2^0, 2^0.33, 2^0.66] on each level.
+        aspect_ratios (List[int]): Aspect ratios of anchor boxes
+        pyramid_levels (List[int]): Levels from which features are taken. Needed to calculate stride
+        anchor_scale (float): scale of size of the base anchor. Lower values allows detection of smaller objects.
+
+    Returns:
+        anchor_boxes (torch.Tensor): stacked anchor boxes on all feature levels. shape [N, 4]. 
+            boxes are in 'ltrb' format
+    """
+    
+    if isinstance(image_size, int):
+        image_size = (image_size, image_size)
+    scale_vals = [anchor_scale * 2 ** (i / num_scales) for i in range(num_scales)]
+    # from lowest stride to largest. Anchors from models should be in the same order!
+    strides = [2**i for i in pyramid_levels]
+    
+    # get offsets for anchor boxes for one pixel
+    # can rewrite in pure Torch but using np is more convenient. This function usually should only be called once
+    num_anchors = len(scale_vals) * len(aspect_ratios)
+    ratio_vals_sq = np.sqrt(np.repeat(aspect_ratios, len(scale_vals)))
+    scale_vals_tiled = np.tile(scale_vals, len(aspect_ratios))[:, np.newaxis]
+    wh = np.stack([np.ones(num_anchors) * ratio_vals_sq, np.ones(num_anchors) / ratio_vals_sq], axis=1) 
+    lt = - 0.5 * wh * scale_vals_tiled
+    rb = 0.5 * wh * scale_vals_tiled
+    base_offsets = torch.from_numpy(np.hstack([lt, rb])) # [num_anchors, 4]
+    base_offsets = base_offsets.view(-1, 1, 1, 4) # [num_anchors, 1, 1, 4]
+
+    # generate anchor boxes for all given strides
+    all_anchors = []
+    for stride in strides:
+        x, y = torch.meshgrid([torch.arange(stride / 2, image_size[i], stride) for i in range(2)])
+        xyxy = torch.stack((x, y, x, y), 2).unsqueeze(0) 
+        anchors = (xyxy + base_offsets * stride).view(-1, 4).contiguous()
+        all_anchors.append(anchors)
+    all_anchors = torch.cat(all_anchors)
+    # clip boxes to image. Not sure if we really need to clip them
+    # all_anchors[:, 0::2] = all_anchors[:, 0::2].clamp(0, image_size[0])
+    # all_anchors[:, 1::2] = all_anchors[:, 1::2].clamp(0, image_size[1])
+    return all_anchors
+
+def generate_targets(anchors, gt_boxes, num_classes, matched_iou=0.5, unmatched_iou=0.4):
+    """Generate targets for regression and classification for SINGLE image
+    
+    Based on IoU between anchor and true bounding box there are three types of anchor boxes
+    1) IoU >= matched_iou: Highest similarity. Matched/Positive. Mask value is 1
+    2) matched_iou > IoU >= unmatched_iou: Medium similarity. Ignored. Mask value is -1
+    3) unmatched_iou > IoU: Lowest similarity. Unmatched/Negative. Mask value is 0
+    
+    Args:
+        anchors (torch.Tensor): all anchors on a single image. shape [N, 4]
+        gt_boxes (torch.Tesor): all groud truth bounding boxes and classes on the image. shape [N, 5]
+            classes are expected to be in the last column. 
+            bboxes are in `ltrb` format!
+        num_classes (int): number of classes. needed for one-hot encoding labels
+        matched_iou (float):  
+        unmatched_iou (float):
+    
+    Returns:
+        box_target, cls_target, matches_mask
+    
+    """
+
+    gt_boxes, gt_classes = gt_boxes.split(4, dim=1)
+    overlap = box_iou(anchors, gt_boxes)
+    
+    # Keep best box per anchor
+    overlap, indices = overlap.max(1)
+    box_target = box2delta(gt_boxes[indices], anchors) # I've double checked that it's corrects
+    # TODO: add test that anchor + box target gives gt_bbox
+    
+    # There are three types of anchors. 
+    # matched (with objects), unmatched (with background), and in between (which should be ignored)
+    IGNORED_VALUE = -1
+    UNMATCHED_VALUE = 0
+    matches_mask = torch.ones_like(overlap) * IGNORED_VALUE
+    matches_mask[overlap < unmatched_iou] = UNMATCHED_VALUE # background
+    matches_mask[overlap >= matched_iou] = 1
+
+    # Generate one-hot-encoded target classes
+    cls_target = torch.zeros(
+        (anchors.size(0), num_classes + 1), device=gt_classes.device, dtype=gt_classes.dtype
+    )
+    gt_classes = gt_classes[indices].long()
+    gt_classes[overlap < unmatched_iou] = num_classes  # background has no class
+    cls_target.scatter_(1, gt_classes, 1)
+    cls_target = cls_target[:, :num_classes] # remove background class from one-hot
+
+    return cls_target, box_target, matches_mask
\ No newline at end of file

From c283581154cdaafa826a2e2b10237506375eb6a6 Mon Sep 17 00:00:00 2001
From: Emil Zakirov <bonlimezak@gmail.com>
Date: Wed, 6 May 2020 19:23:06 +0300
Subject: [PATCH 03/54] add smooth l1 loss

---
 pytorch_tools/losses/__init__.py |  1 +
 pytorch_tools/losses/huber.py    | 33 ++++++++++++++++++++++++++++++++
 tests/losses/test_losses.py      |  6 ++++++
 3 files changed, 40 insertions(+)
 create mode 100644 pytorch_tools/losses/huber.py

diff --git a/pytorch_tools/losses/__init__.py b/pytorch_tools/losses/__init__.py
index d2c302f..962fa1c 100644
--- a/pytorch_tools/losses/__init__.py
+++ b/pytorch_tools/losses/__init__.py
@@ -10,6 +10,7 @@
 from .vgg_loss import ContentLoss, StyleLoss
 from .smooth import CrossEntropyLoss
 from .hinge import BinaryHinge
+from .huber import SmoothL1Loss
 
 from .functional import focal_loss_with_logits
 from .functional import soft_dice_score
diff --git a/pytorch_tools/losses/huber.py b/pytorch_tools/losses/huber.py
new file mode 100644
index 0000000..99d4337
--- /dev/null
+++ b/pytorch_tools/losses/huber.py
@@ -0,0 +1,33 @@
+from .base import Loss
+from .base import Reduction
+
+class SmoothL1Loss(Loss):
+    """Huber loss aka Smooth L1 Loss
+    
+    loss = 0.5 * x^2                  if |x| <= d
+    loss = 0.5 * d^2 + d * (|x| - d)  if |x| > d
+
+    Args:
+        delta (float): point where the Huber loss function changes from a quadratic to linear
+        reduction (str): The reduction type to apply to the output. {'none', 'mean', 'sum'}.
+            'none' - no reduction will be applied
+            'sum' - the output will be summed
+            'mean' - the sum of the output will be divided by the number of elements in the output
+    """
+
+    def __init__(self, delta=0.1, reduction="none"):
+        super().__init__()
+        self.delta = delta
+        self.reduction = Reduction(reduction)
+
+    def forward(self, pred, target):
+        x = (pred - target).abs()
+        l1 = self.delta * (x - 0.5 * self.delta)
+        l2 = 0.5 * x.pow(2)
+
+        loss = l1.where(x >= self.delta, l2)
+        if self.reduction == Reduction.MEAN:
+            loss = loss.mean()
+        elif self.reduction == Reduction.SUM:
+            loss = loss.sum()
+        return loss
\ No newline at end of file
diff --git a/tests/losses/test_losses.py b/tests/losses/test_losses.py
index 74df11b..cf3090e 100644
--- a/tests/losses/test_losses.py
+++ b/tests/losses/test_losses.py
@@ -386,3 +386,9 @@ def test_multiclass_multilabel_lovasz():
 
 def test_binary_hinge():
     assert losses.BinaryHinge()(INP_IMG_BINARY, TARGET_IMG_BINARY)
+
+
+@pytest.mark.parametrize("reduction", ["sum", "mean", "none"])
+def test_smoothl1(reduction):
+    loss_my = losses.SmoothL1Loss(delta=1, reduction=reduction)(INP, TARGET_MULTILABEL)
+    loss_torch = F.smooth_l1_loss(INP, TARGET_MULTILABEL, reduction=reduction)
\ No newline at end of file

From 8efe866b5ec9971ccccb8bda84397c5069856688 Mon Sep 17 00:00:00 2001
From: Emil Zakirov <bonlimezak@gmail.com>
Date: Wed, 6 May 2020 19:56:02 +0300
Subject: [PATCH 04/54] support generate targets for batches

---
 pytorch_tools/utils/box.py | 103 +++++++++++++++++++++++++++----------
 1 file changed, 75 insertions(+), 28 deletions(-)

diff --git a/pytorch_tools/utils/box.py b/pytorch_tools/utils/box.py
index 172fcf1..e446d63 100644
--- a/pytorch_tools/utils/box.py
+++ b/pytorch_tools/utils/box.py
@@ -118,8 +118,8 @@ def generate_anchors_boxes(
     # all_anchors[:, 1::2] = all_anchors[:, 1::2].clamp(0, image_size[1])
     return all_anchors
 
-def generate_targets(anchors, gt_boxes, num_classes, matched_iou=0.5, unmatched_iou=0.4):
-    """Generate targets for regression and classification for SINGLE image
+def generate_targets(anchors, batch_gt_boxes, num_classes, matched_iou=0.5, unmatched_iou=0.4):
+    """Generate targets for regression and classification
     
     Based on IoU between anchor and true bounding box there are three types of anchor boxes
     1) IoU >= matched_iou: Highest similarity. Matched/Positive. Mask value is 1
@@ -128,7 +128,7 @@ def generate_targets(anchors, gt_boxes, num_classes, matched_iou=0.5, unmatched_
     
     Args:
         anchors (torch.Tensor): all anchors on a single image. shape [N, 4]
-        gt_boxes (torch.Tesor): all groud truth bounding boxes and classes on the image. shape [N, 5]
+        batch_gt_boxes (torch.Tesor): all groud truth bounding boxes and classes for the batch. shape [BS, N, 5]
             classes are expected to be in the last column. 
             bboxes are in `ltrb` format!
         num_classes (int): number of classes. needed for one-hot encoding labels
@@ -139,30 +139,77 @@ def generate_targets(anchors, gt_boxes, num_classes, matched_iou=0.5, unmatched_
         box_target, cls_target, matches_mask
     
     """
-
-    gt_boxes, gt_classes = gt_boxes.split(4, dim=1)
-    overlap = box_iou(anchors, gt_boxes)
+    def _generate_single_targets(gt_boxes):
+        gt_boxes, gt_classes = gt_boxes.split(4, dim=1)
+        overlap = box_iou(anchors, gt_boxes)
+        
+        # Keep best box per anchor
+        overlap, indices = overlap.max(1)
+        box_target = box2delta(gt_boxes[indices], anchors) # I've double checked that it's corrects
+        # TODO: add test that anchor + box target gives gt_bbox
+        
+        # There are three types of anchors. 
+        # matched (with objects), unmatched (with background), and in between (which should be ignored)
+        IGNORED_VALUE = -1
+        UNMATCHED_VALUE = 0
+        matches_mask = torch.ones_like(overlap) * IGNORED_VALUE
+        matches_mask[overlap < unmatched_iou] = UNMATCHED_VALUE # background
+        matches_mask[overlap >= matched_iou] = 1
+
+        # Generate one-hot-encoded target classes
+        cls_target = torch.zeros(
+            (anchors.size(0), num_classes + 1), device=gt_classes.device, dtype=gt_classes.dtype
+        )
+        gt_classes = gt_classes[indices].long()
+        gt_classes[overlap < unmatched_iou] = num_classes  # background has no class
+        cls_target.scatter_(1, gt_classes, 1)
+        cls_target = cls_target[:, :num_classes] # remove background class from one-hot
+
+        return cls_target, box_target, matches_mask
     
-    # Keep best box per anchor
-    overlap, indices = overlap.max(1)
-    box_target = box2delta(gt_boxes[indices], anchors) # I've double checked that it's corrects
-    # TODO: add test that anchor + box target gives gt_bbox
+    anchors = anchors.to(batch_gt_boxes) # change device & type if needed
+    batch_results = ([], [], [])
+    for single_gt_boxes in batch_gt_boxes:
+        single_target_results = _generate_single_targets(single_gt_boxes)
+        for batch_res, single_res in zip(batch_results, single_target_results):
+            batch_res.append(single_res)
+    b_cls_target, b_box_target, b_matches_mask = [torch.stack(targets) for targets in batch_results]
+    return b_cls_target, b_box_target, b_matches_mask
     
-    # There are three types of anchors. 
-    # matched (with objects), unmatched (with background), and in between (which should be ignored)
-    IGNORED_VALUE = -1
-    UNMATCHED_VALUE = 0
-    matches_mask = torch.ones_like(overlap) * IGNORED_VALUE
-    matches_mask[overlap < unmatched_iou] = UNMATCHED_VALUE # background
-    matches_mask[overlap >= matched_iou] = 1
-
-    # Generate one-hot-encoded target classes
-    cls_target = torch.zeros(
-        (anchors.size(0), num_classes + 1), device=gt_classes.device, dtype=gt_classes.dtype
-    )
-    gt_classes = gt_classes[indices].long()
-    gt_classes[overlap < unmatched_iou] = num_classes  # background has no class
-    cls_target.scatter_(1, gt_classes, 1)
-    cls_target = cls_target[:, :num_classes] # remove background class from one-hot
-
-    return cls_target, box_target, matches_mask
\ No newline at end of file
+# copied from torchvision
+def batched_nms(boxes, scores, idxs, iou_threshold):
+    # type: (Tensor, Tensor, Tensor, float)
+    """
+    Performs non-maximum suppression in a batched fashion.
+    Each index value correspond to a category, and NMS
+    will not be applied between elements of different categories.
+    Parameters
+    ----------
+    boxes : Tensor[N, 4]
+        boxes where NMS will be performed. They
+        are expected to be in (x1, y1, x2, y2) format
+    scores : Tensor[N]
+        scores for each one of the boxes
+    idxs : Tensor[N]
+        indices of the categories for each one of the boxes.
+    iou_threshold : float
+        discards all overlapping boxes
+        with IoU > iou_threshold
+    Returns
+    -------
+    keep : Tensor
+        int64 tensor with the indices of
+        the elements that have been kept by NMS, sorted
+        in decreasing order of scores
+    """
+    if boxes.numel() == 0:
+        return torch.empty((0,), dtype=torch.int64, device=boxes.device)
+    # strategy: in order to perform NMS independently per class.
+    # we add an offset to all the boxes. The offset is dependent
+    # only on the class idx, and is large enough so that boxes
+    # from different classes do not overlap
+    max_coordinate = boxes.max()
+    offsets = idxs.to(boxes) * (max_coordinate + 1)
+    boxes_for_nms = boxes + offsets[:, None]
+    keep = torch.ops.torchvision.nms(boxes_for_nms, scores, iou_threshold)
+    return keep
\ No newline at end of file

From 2ae009db21c410aa9e4a3775ace1534d0fc645ee Mon Sep 17 00:00:00 2001
From: Emil Zakirov <bonlimezak@gmail.com>
Date: Wed, 6 May 2020 21:45:00 +0300
Subject: [PATCH 05/54] move timer inside callback

---
 pytorch_tools/fit_wrapper/callbacks.py | 13 +++++++++----
 pytorch_tools/fit_wrapper/state.py     |  2 --
 pytorch_tools/fit_wrapper/wrapper.py   |  6 +++---
 3 files changed, 12 insertions(+), 9 deletions(-)

diff --git a/pytorch_tools/fit_wrapper/callbacks.py b/pytorch_tools/fit_wrapper/callbacks.py
index 1c782cd..52b2fca 100644
--- a/pytorch_tools/fit_wrapper/callbacks.py
+++ b/pytorch_tools/fit_wrapper/callbacks.py
@@ -10,6 +10,7 @@
 from torch.utils.tensorboard import SummaryWriter
 from .state import RunnerState
 from pytorch_tools.utils.misc import listify
+from pytorch_tools.utils.misc import TimeMeter
 from pytorch_tools.utils.visualization import plot_confusion_matrix
 from pytorch_tools.utils.visualization import render_figure_to_tensor
 
@@ -113,18 +114,22 @@ class Timer(Callback):
     def __init__(self):
         super().__init__()
         self.has_printed = False
+        self.timer = TimeMeter()
 
     def on_batch_begin(self):
-        self.state.timer.batch_start()
+        self.timer.batch_start()
 
     def on_batch_end(self):
-        self.state.timer.batch_end()
+        self.timer.batch_end()
+
+    def on_loader_begin(self):
+        self.timer.reset()
 
     def on_loader_end(self):
         if not self.has_printed:
             self.has_printed = True
-            d_time = self.state.timer.data_time.avg_smooth
-            b_time = self.state.timer.batch_time.avg_smooth
+            d_time = self.timer.data_time.avg_smooth
+            b_time = self.timer.batch_time.avg_smooth
             print(f"\nTimeMeter profiling. Data time: {d_time:.2E}s. Model time: {b_time:.2E}s \n")
 
 
diff --git a/pytorch_tools/fit_wrapper/state.py b/pytorch_tools/fit_wrapper/state.py
index 95ca30c..336ffcd 100644
--- a/pytorch_tools/fit_wrapper/state.py
+++ b/pytorch_tools/fit_wrapper/state.py
@@ -1,6 +1,5 @@
 from ..utils.misc import listify
 from ..utils.misc import AverageMeter
-from ..utils.misc import TimeMeter
 
 
 class RunnerState:
@@ -39,7 +38,6 @@ def __init__(
         self.loss_meter = AverageMeter("loss")
 
         # for timer callback
-        self.timer = TimeMeter()
         self.__is_frozen = True
 
     def __setattr__(self, key, value):
diff --git a/pytorch_tools/fit_wrapper/wrapper.py b/pytorch_tools/fit_wrapper/wrapper.py
index 97506e1..cb57c77 100644
--- a/pytorch_tools/fit_wrapper/wrapper.py
+++ b/pytorch_tools/fit_wrapper/wrapper.py
@@ -88,12 +88,12 @@ def _make_step(self):
 
         # update metrics
         self.state.loss_meter.update(to_numpy(loss))
-        for metric, meter in zip(self.state.metrics, self.state.metric_meters):
-            meter.update(to_numpy(metric(output, target).squeeze()))
+        with torch.no_grad():
+            for metric, meter in zip(self.state.metrics, self.state.metric_meters):
+                meter.update(to_numpy(metric(output, target).squeeze()))
 
     def _run_loader(self, loader, steps=None):
         self.state.loss_meter.reset()
-        self.state.timer.reset()
         for metric in self.state.metric_meters:
             metric.reset()
         self.state.epoch_size = steps or len(loader)  # steps overwrites len

From e6036374bde74db35121ee0b6ca58a9f7e4af918 Mon Sep 17 00:00:00 2001
From: Emil Zakirov <bonlimezak@gmail.com>
Date: Thu, 7 May 2020 18:43:25 +0300
Subject: [PATCH 06/54] add function to convert to weight standartization conv

---
 .../modules/weight_standartization.py         | 46 +++++++++++--------
 1 file changed, 27 insertions(+), 19 deletions(-)

diff --git a/pytorch_tools/modules/weight_standartization.py b/pytorch_tools/modules/weight_standartization.py
index 50e8631..5b9221a 100644
--- a/pytorch_tools/modules/weight_standartization.py
+++ b/pytorch_tools/modules/weight_standartization.py
@@ -1,3 +1,4 @@
+import torch
 from torch import nn
 import torch.nn.functional as F
 
@@ -15,23 +16,30 @@ def forward(self, x):
         weight = weight.div(std.expand_as(weight))
         return F.conv2d(x, weight, self.bias, self.stride, self.padding, self.dilation, self.groups)
 
-# code from random issue on github. 
-def convertConv2WeightStand(module, nextChild=None):
-    mod = module
-    norm_list = [torch.nn.modules.batchnorm.BatchNorm1d, torch.nn.modules.batchnorm.BatchNorm2d, torch.nn.modules.batchnorm.BatchNorm3d, torch.nn.GroupNorm, torch.nn.LayerNorm]
-    conv_list = [torch.nn.Conv1d, torch.nn.Conv2d, torch.nn.Conv3d, torch.nn.ConvTranspose1d, torch.nn.ConvTranspose2d, torch.nn.ConvTranspose3d]
-    for norm in norm_list:
-        for conv in conv_list:
-            if isinstance(mod, conv) and isinstance(nextChild, norm):
-                mod = Conv2d(mod.in_channels, mod.out_channels, mod.kernel_size, mod.stride,
-                 mod.padding, mod.dilation, mod.groups, mod.bias!=None)
-
-    moduleChildList = list(module.named_children())
-    for index, [name, child] in enumerate(moduleChildList):
-        nextChild = None
-        if index < len(moduleChildList) -1:
-            nextChild = moduleChildList[index+1][1]
-        mod.add_module(name, convertConv2WeightStand(child, nextChild))
-
-    return mod
+# code from SyncBatchNorm in pytorch
+@torch.no_grad() # not sure if torch.no_grad is needed. but just in case
+def conv_to_ws_conv(module):
+        module_output = module
+        if isinstance(module, torch.nn.Conv2d):
+            module_output = WS_Conv2d(
+                in_channels=module.in_channels,
+                out_channels=module.out_channels,
+                kernel_size=module.kernel_size,
+                stride=module.stride,
+                padding=module.padding,
+                dilation=module.dilation,
+                # groups are also present in DepthWiseConvs which we don't want to patch
+                # TODO: fix this
+                groups=module.groups, 
+                bias=module.bias,
+            )
+            module_output.weight.copy_(module.weight)
+            module_output.weight.requires_grad = module.weight.requires_grad
+            if module.bias:
+                module_output.bias.copy_(module.bias)
+                module_output.bias.requires_grad = module.bias.requires_grad
 
+        for name, child in module.named_children():
+            module_output.add_module(name, conv_to_ws_conv(child))
+        del module
+        return module_output
\ No newline at end of file

From 01c3b1fe946feade56f408947710815fedc1e3a4 Mon Sep 17 00:00:00 2001
From: Emil Zakirov <bonlimezak@gmail.com>
Date: Thu, 7 May 2020 18:44:20 +0300
Subject: [PATCH 07/54] add box_area function

---
 pytorch_tools/utils/box.py | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/pytorch_tools/utils/box.py b/pytorch_tools/utils/box.py
index e446d63..92affe9 100644
--- a/pytorch_tools/utils/box.py
+++ b/pytorch_tools/utils/box.py
@@ -36,6 +36,12 @@ def delta2box(deltas, anchors):
 
     return torch.cat([pred_ctr - 0.5 * pred_wh, pred_ctr + 0.5 * pred_wh - 1], 1)
 
+def box_area(box):
+    """Args:
+    box (torch.Tensor): shape [N, 4] in 'ltrb' format
+    """
+    return (box[:, 2] - box[:, 0]) * (box[:, 3] - box[:, 1])
+
 # implementation from https://github.com/kuangliu/torchcv/blob/master/torchcv/utils/box.py
 # with slight modifications
 def box_iou(boxes1, boxes2):
@@ -49,8 +55,8 @@ def box_iou(boxes1, boxes2):
         iou (Tensor[N, M]): the NxM matrix containing the pairwise
             IoU values for every element in boxes1 and boxes2
     """
-    area1 = (boxes1[:, 2] - boxes1[:, 0]) * (boxes1[:, 3] - boxes1[:, 1])
-    area2 = (boxes2[:, 2] - boxes2[:, 0]) * (boxes2[:, 3] - boxes2[:, 1])
+    area1 = box_area(boxes1)
+    area2 = box_area(boxes2)
 
     lt = torch.max(boxes1[:, None, :2], boxes2[:, :2])  # [N,M,2]
     rb = torch.min(boxes1[:, None, 2:], boxes2[:, 2:])  # [N,M,2]
@@ -86,6 +92,7 @@ def generate_anchors_boxes(
     Returns:
         anchor_boxes (torch.Tensor): stacked anchor boxes on all feature levels. shape [N, 4]. 
             boxes are in 'ltrb' format
+        num_anchors (int): number of anchors per location
     """
     
     if isinstance(image_size, int):
@@ -116,7 +123,7 @@ def generate_anchors_boxes(
     # clip boxes to image. Not sure if we really need to clip them
     # all_anchors[:, 0::2] = all_anchors[:, 0::2].clamp(0, image_size[0])
     # all_anchors[:, 1::2] = all_anchors[:, 1::2].clamp(0, image_size[1])
-    return all_anchors
+    return all_anchors, num_anchors
 
 def generate_targets(anchors, batch_gt_boxes, num_classes, matched_iou=0.5, unmatched_iou=0.4):
     """Generate targets for regression and classification

From a5c267f120125aa5292ce67b2ba1f1f2f71c1aba Mon Sep 17 00:00:00 2001
From: Emil Zakirov <bonlimezak@gmail.com>
Date: Thu, 7 May 2020 19:26:56 +0300
Subject: [PATCH 08/54] fix ws

---
 pytorch_tools/modules/__init__.py               |  1 +
 pytorch_tools/modules/weight_standartization.py | 12 ++++++------
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/pytorch_tools/modules/__init__.py b/pytorch_tools/modules/__init__.py
index 86a776f..ee20f3c 100644
--- a/pytorch_tools/modules/__init__.py
+++ b/pytorch_tools/modules/__init__.py
@@ -13,6 +13,7 @@
 from .residual import SEModule
 
 # from .residual import Transition, DenseLayer
+from .weight_standartization import conv_to_ws_conv
 
 from .activations import ACT_DICT
 from .activations import ACT_FUNC_DICT
diff --git a/pytorch_tools/modules/weight_standartization.py b/pytorch_tools/modules/weight_standartization.py
index 5b9221a..5f8e926 100644
--- a/pytorch_tools/modules/weight_standartization.py
+++ b/pytorch_tools/modules/weight_standartization.py
@@ -17,7 +17,6 @@ def forward(self, x):
         return F.conv2d(x, weight, self.bias, self.stride, self.padding, self.dilation, self.groups)
 
 # code from SyncBatchNorm in pytorch
-@torch.no_grad() # not sure if torch.no_grad is needed. but just in case
 def conv_to_ws_conv(module):
         module_output = module
         if isinstance(module, torch.nn.Conv2d):
@@ -33,11 +32,12 @@ def conv_to_ws_conv(module):
                 groups=module.groups, 
                 bias=module.bias,
             )
-            module_output.weight.copy_(module.weight)
-            module_output.weight.requires_grad = module.weight.requires_grad
-            if module.bias:
-                module_output.bias.copy_(module.bias)
-                module_output.bias.requires_grad = module.bias.requires_grad
+            with torch.no_grad(): # not sure if torch.no_grad is needed. but just in case
+                module_output.weight.copy_(module.weight)
+                module_output.weight.requires_grad = module.weight.requires_grad
+                if module.bias:
+                    module_output.bias.copy_(module.bias)
+                    module_output.bias.requires_grad = module.bias.requires_grad
 
         for name, child in module.named_children():
             module_output.add_module(name, conv_to_ws_conv(child))

From 4a48f977cfaa46e53d21fdf400082e14c31d54f5 Mon Sep 17 00:00:00 2001
From: Emil Zakirov <bonlimezak@gmail.com>
Date: Fri, 8 May 2020 01:39:30 +0300
Subject: [PATCH 09/54] add metrics reduction in FileLogger. Check `mode` in
 PhasesScheduler

---
 pytorch_tools/fit_wrapper/callbacks.py | 31 +++++++++++++++++++-------
 tests/fit_wrapper/test_runner.py       | 12 +++++++++-
 2 files changed, 34 insertions(+), 9 deletions(-)

diff --git a/pytorch_tools/fit_wrapper/callbacks.py b/pytorch_tools/fit_wrapper/callbacks.py
index 52b2fca..57eacc8 100644
--- a/pytorch_tools/fit_wrapper/callbacks.py
+++ b/pytorch_tools/fit_wrapper/callbacks.py
@@ -9,8 +9,7 @@
 import torch
 from torch.utils.tensorboard import SummaryWriter
 from .state import RunnerState
-from pytorch_tools.utils.misc import listify
-from pytorch_tools.utils.misc import TimeMeter
+import pytorch_tools.utils.misc as utils
 from pytorch_tools.utils.visualization import plot_confusion_matrix
 from pytorch_tools.utils.visualization import render_figure_to_tensor
 
@@ -66,7 +65,7 @@ class Callbacks(Callback):
 
     def __init__(self, callbacks):
         super().__init__()
-        self.callbacks = listify(callbacks)
+        self.callbacks = utils.listify(callbacks)
 
     def set_state(self, state):
         for callback in self.callbacks:
@@ -114,7 +113,7 @@ class Timer(Callback):
     def __init__(self):
         super().__init__()
         self.has_printed = False
-        self.timer = TimeMeter()
+        self.timer = utils.TimeMeter()
 
     def on_batch_begin(self):
         self.timer.batch_start()
@@ -136,6 +135,7 @@ def on_loader_end(self):
 class PhasesScheduler(Callback):
     """
     Scheduler that uses `phases` to process updates.
+    Supported `mode`'s are {`linear`, `cos`}
 
     Args:
         phases (List[Dict]): phases
@@ -160,9 +160,9 @@ def __init__(self, phases, change_every=50):
         super(PhasesScheduler, self).__init__()
 
     def _format_phase(self, phase):
-        phase["ep"] = listify(phase["ep"])
-        phase["lr"] = listify(phase["lr"])
-        phase["mom"] = listify(phase.get("mom", None))  # optional
+        phase["ep"] = utils.listify(phase["ep"])
+        phase["lr"] = utils.listify(phase["lr"])
+        phase["mom"] = utils.listify(phase.get("mom", None))  # optional
         if len(phase["lr"]) == 2 or len(phase["mom"]) == 2:
             phase["mode"] = phase.get("mode", "linear")
             assert len(phase["ep"]) == 2, "Linear learning rates must contain end epoch"
@@ -175,6 +175,8 @@ def _schedule(start, end, pct, mode):
             return start + (end - start) * pct
         elif mode == "cos":
             return end + (start - end) / 2 * (math.cos(math.pi * pct) + 1)
+        else:
+            raise ValueError(f"Mode: `{mode}` is not supported in PhasesScheduler")
 
     def _get_lr_mom(self, batch_curr):
         phase = self.phase
@@ -478,7 +480,8 @@ def on_batch_end(self):
 
 
 class FileLogger(Callback):
-    """Logs loss and metrics every epoch into file
+    """Logs loss and metrics every epoch into file.
+    If launched in distributed mode - reduces metrics before logging
     Args:
         log_dir (str): path where to store the logs
         logger (logging.Logger): external logger. Default None
@@ -493,6 +496,8 @@ def on_epoch_begin(self):
         self.logger.info(f"Epoch {self.state.epoch_log} | lr {self.current_lr:.3f}")
 
     def on_epoch_end(self):
+        if utils.env_world_size() > 1:
+            self.reduce_metrics()
         loss, metrics = self.state.train_loss, self.state.train_metrics
         self.logger.info("Train " + self._format_meters(loss, metrics))
         if self.state.val_loss is not None:
@@ -518,6 +523,16 @@ def current_lr(self):
     def _format_meters(loss, metrics):
         return f"loss: {loss.avg:.4f} | " + " | ".join(f"{m.name}: {m.avg:.4f}" for m in metrics)
 
+    def reduce_metrics(self):
+        # can't reduce AverageMeter so need to reduce every attribute separately
+        meters = self.state.train_metrics + [self.state.train_loss,]
+        if self.state.val_loss is not None:
+            meters = meters + self.state.val_metrics + [self.state.val_loss,]
+        reduce_attributes = ["val", "avg", "avg_smooth", "sum", "count"]
+        for meter in meters:
+            for attr in reduce_attributes:
+                old_value = utils.to_tensor([getattr(meter, attr)]).float().cuda()
+                setattr(meter, attr, utils.reduce_tensor(old_value).cpu().numpy()[0])
 
 class Mixup(Callback):
     """Performs mixup on input. Only for classification.
diff --git a/tests/fit_wrapper/test_runner.py b/tests/fit_wrapper/test_runner.py
index 6f16881..b600d37 100644
--- a/tests/fit_wrapper/test_runner.py
+++ b/tests/fit_wrapper/test_runner.py
@@ -156,4 +156,14 @@ def test_segm_callback(callback):
         criterion=TEST_CRITERION,
         callbacks=callback,
     )
-    runner.fit(TEST_SEGM_LOADER, epochs=2)
\ No newline at end of file
+    runner.fit(TEST_SEGM_LOADER, epochs=2)
+
+def test_invalid_phases_scheduler_mode():
+    runner = Runner(
+        model=TEST_MODEL,
+        optimizer=TEST_OPTIMIZER,
+        criterion=TEST_CRITERION,
+        callbacks=pt_clb.PhasesScheduler([{"ep":[0,1], "lr":[0,1], "mode":"new_mode" },])
+    )
+    with pytest.raises(ValueError):
+        runner.fit(TEST_LOADER, epochs=2)
\ No newline at end of file

From ee199e25e3ca9b1fb4b879cbb8ecebe7bedfc082 Mon Sep 17 00:00:00 2001
From: Emil Zakirov <bonlimezak@gmail.com>
Date: Fri, 8 May 2020 14:31:16 +0300
Subject: [PATCH 10/54] add group norm and GN + WS model weights

---
 pytorch_tools/models/resnet.py | 41 ++++++++++++++++++++++++++++++----
 1 file changed, 37 insertions(+), 4 deletions(-)

diff --git a/pytorch_tools/models/resnet.py b/pytorch_tools/models/resnet.py
index 7fbb4f8..0e396d7 100644
--- a/pytorch_tools/models/resnet.py
+++ b/pytorch_tools/models/resnet.py
@@ -307,10 +307,32 @@ def keep_prob(self):
     "resnet50": {
         "default": {"params": {"block": Bottleneck, "layers": [3, 4, 6, 3]}, **DEFAULT_IMAGENET_SETTINGS,},
         "imagenet": {"url": "https://download.pytorch.org/models/resnet50-19c8e357.pth"},
+        # I couldn't validate this weights because they give Acc@1 0.1 maybe a bug somewhere. Still leaving them just in case 
+        # it works better that starting from scratch
+        "imagenet_gn": {
+            "url": "https://github.com/bonlime/pytorch-tools/releases/download/v0.1.2/R-101-GN-abf6008e.pth", 
+            "params": {"norm_layer": "agn"}
+        },
+        # Acc@1: 76.33. Acc@5: 93.34. This weights only work with weight standardization!
+        "imagenet_gn_ws": {
+            "url": "https://github.com/bonlime/pytorch-tools/releases/download/v0.1.2/R-50-GN-WS-fd84efb6.pth", 
+            "params": {"norm_layer": "agn"}
+        },
     },
     "resnet101": {
         "default": {"params": {"block": Bottleneck, "layers": [3, 4, 23, 3]}, **DEFAULT_IMAGENET_SETTINGS,},
         "imagenet": {"url": "https://download.pytorch.org/models/resnet101-5d3b4d8f.pth"},
+        # I couldn't validate this weights because they give Acc@1 0.1 maybe a bug somewhere. Still leaving them just in case 
+        # it works better that starting from scratch
+        "imagenet_gn": {
+            "url": "https://github.com/bonlime/pytorch-tools/releases/download/v0.1.2/R-101-GN-abf6008e.pth", 
+            "params": {"norm_layer": "agn"}
+        },
+        # Acc@1: 77.85. Acc@5: 93.90. This weights only work with weight standardization!
+        "imagenet_gn_ws": {
+            "url": "https://github.com/bonlime/pytorch-tools/releases/download/v0.1.2/R-101-GN-WS-c067a7de.pth",
+            "params": {"norm_layer": "agn"}
+        },
     },
     "resnet152": {
         "default": {"params": {"block": Bottleneck, "layers": [3, 8, 36, 3]}, **DEFAULT_IMAGENET_SETTINGS,},
@@ -337,25 +359,36 @@ def keep_prob(self):
             "params": {"block": Bottleneck, "layers": [3, 4, 6, 3], "base_width": 4, "groups": 32,},
             **DEFAULT_IMAGENET_SETTINGS,
         },
-        "imagenet": {  # Acc@1: 75.80. Acc@5: 92.71.
-            "url": "https://download.pytorch.org/models/resnext50_32x4d-7cdf4587.pth"
-        },
+        # Acc@1: 75.80. Acc@5: 92.71.
+        "imagenet": {"url": "https://download.pytorch.org/models/resnext50_32x4d-7cdf4587.pth"},
         # weights from rwightman
         "imagenet2": {
             "url": "https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/resnext50d_32x4d-103e99f8.pth"
         },
+        # Acc@1: 77.28. Acc@5: 93.61. This weights only work with weight standardization!
+        "imagenet_gn_ws": {
+            "url": "https://github.com/bonlime/pytorch-tools/releases/download/v0.1.2/X-50-GN-WS-2dea43a8.pth", 
+            "params": {"norm_layer": "agn"}
+        },
     },
     "resnext101_32x4d": {
         "default": {
             "params": {"block": Bottleneck, "layers": [3, 4, 23, 3], "base_width": 4, "groups": 32,},
             **DEFAULT_IMAGENET_SETTINGS,
-        },  # No pretrained
+        },  # No imagenet pretrained
+        # 78.19. Acc@5: 93.98 This weights only work with weight standardization!
+        "imagenet_gn_ws": {
+            "url": "https://github.com/bonlime/pytorch-tools/releases/download/v0.1.2/X-101-GN-WS-eb1224cd.pth",
+            "params": {"norm_layer": "agn"},
+        }
+
     },
     "resnext101_32x8d": {
         "default": {
             "params": {"block": Bottleneck, "layers": [3, 4, 23, 3], "base_width": 8, "groups": 32,},
             **DEFAULT_IMAGENET_SETTINGS,
         },
+        # on 8.05.20 this link was broken. maybe need to fix in the future
         "imagenet": {"url": "https://download.pytorch.org/models/resnext101_32x8d-8ba56ff5.pth"},
         # pretrained on weakly labeled instagram and then tuned on Imagenet
         "imagenet_ig": {"url": "https://download.pytorch.org/models/ig_resnext101_32x8-c38310e5.pth"},

From 53e3a53ed7b5e960f353128ace467d1f32086146 Mon Sep 17 00:00:00 2001
From: Emil Zakirov <bonlimezak@gmail.com>
Date: Fri, 8 May 2020 15:48:52 +0300
Subject: [PATCH 11/54] minor update to README and docs

---
 pytorch_tools/fit_wrapper/README.md         | 11 +++++++++-
 pytorch_tools/models/README.md              | 12 ++++++++++-
 pytorch_tools/models/efficientnet.py        |  6 +++---
 pytorch_tools/optim/README.md               |  2 +-
 pytorch_tools/segmentation_models/README.md | 23 ++++++++++++++++++++-
 5 files changed, 47 insertions(+), 7 deletions(-)

diff --git a/pytorch_tools/fit_wrapper/README.md b/pytorch_tools/fit_wrapper/README.md
index fe2e97b..96e00da 100644
--- a/pytorch_tools/fit_wrapper/README.md
+++ b/pytorch_tools/fit_wrapper/README.md
@@ -3,6 +3,8 @@ This module contains model runner (very close to `model.fit` in Keras) for **sup
 `Runner` is used to actually run the train loop calling `Callbacks` at appropriate times.  
 Mixed precision (powered by apex) is supported implicitly. Users are expected to initialize their models before creating runner using `apex.amp.initialize`.
 
+Main idea of this runner is to be as simple as possible. All core functionality is ~100 lines of code. 
+
 ## Minimal example
 This code will run training for 5 epochs.
 ```python
@@ -40,4 +42,11 @@ runner = pt.fit_wrapper.Runner(
     ]
 )
 runner.fit(train_loader, epochs=5, val_loader=val_loader)
-```
\ No newline at end of file
+```
+
+## How to
+### Add custom step logic  
+Monkey patch `Runner._make_step` function with yours  
+
+### Process multiple inputs/outputs
+Instead of modifying Runner move this logic inside Loss function.
\ No newline at end of file
diff --git a/pytorch_tools/models/README.md b/pytorch_tools/models/README.md
index 5d8f823..44994c1 100644
--- a/pytorch_tools/models/README.md
+++ b/pytorch_tools/models/README.md
@@ -9,9 +9,19 @@ All models have `pretrained_settings` attribute with training size, mean, std an
 ## Encoders  
 All models from this repo could be used as feature extractors for both object detection and semantic segmentation. Passing `encoder=True` arg will overwrite `forward` method of the model to return features at 5 different resolutions starting from 1/32 to 1/2.
 
+## Features
+* Unified API. Create `resnet, efficientnet, hrnet` models using the same code
+* Low memory footprint dy to heavy use of inplace operations. Could be reduced even more by using `norm_layer='inplaceabn'`
+* Fast models. As of `04.20` Efficient net's in this repo are the fastest available on GitHub (afaik)
+* Support for custom number of input channels in pretrained models. Try with `resnet34(pretrained='imagenet', in_channels=7)`
+* All core functionality covered with tests
+
+
 ## Repositories used
 * [Torch Vision Main Repo](https://github.com/pytorch/vision)  
 * [Cadene pretrained models](https://github.com/Cadene/pretrained-models.pytorch/)
 * [Ross Wightman models](https://github.com/rwightman/pytorch-image-models/)
 * [Inplace ABN](https://github.com/mapillary/inplace_abn)
-* [Efficient Densenet](https://github.com/gpleiss/efficient_densenet_pytorch)
\ No newline at end of file
+* [Efficient Densenet](https://github.com/gpleiss/efficient_densenet_pytorch)
+* [Official Efficient Net](https://github.com/tensorflow/tpu/tree/master/models/official/efficientnet)  
+* [Original HRNet for Classification](https://github.com/HRNet/HRNet-Image-Classification)
\ No newline at end of file
diff --git a/pytorch_tools/models/efficientnet.py b/pytorch_tools/models/efficientnet.py
index 8f52ccc..f4dc720 100644
--- a/pytorch_tools/models/efficientnet.py
+++ b/pytorch_tools/models/efficientnet.py
@@ -47,12 +47,12 @@ class EfficientNet(nn.Module):
         width_multiplier (float): 
             Multiplyer for number of channels in each block. Don't need to be passed manually
         depth_multiplier (float):
-            Multiplyer for number of InvertedResiduals in each block
+            Multiplyer for number of InvertedResiduals in each block. Don't need to be passed manually
         pretrained (str, optional):
-            If not, returns a model pre-trained on 'str' dataset. `imagenet` is available for every model.
+            If not None, returns a model pre-trained on 'str' dataset. `imagenet` is available for every model.
             NOTE: weights which are loaded into this model were ported from TF. There is a drop in
             accuracy for Imagenet (~1-2% top1) but they work well for finetuning.
-            NOTE 2: models were pretrained on very different resolution. take it into account during finetuning
+            NOTE 2: models were pretrained on very different resolutions. take it into account during finetuning
         num_classes (int):
             Number of classification classes. Defaults to 1000.
         in_channels (int):
diff --git a/pytorch_tools/optim/README.md b/pytorch_tools/optim/README.md
index ca95eee..c1bd7ca 100644
--- a/pytorch_tools/optim/README.md
+++ b/pytorch_tools/optim/README.md
@@ -1,2 +1,2 @@
-# Custom optimizers and utils
+# PyTorch Optimizers and Utils
 Self-explanatory
\ No newline at end of file
diff --git a/pytorch_tools/segmentation_models/README.md b/pytorch_tools/segmentation_models/README.md
index 30404ce..e31e395 100644
--- a/pytorch_tools/segmentation_models/README.md
+++ b/pytorch_tools/segmentation_models/README.md
@@ -1 +1,22 @@
-TODO
\ No newline at end of file
+# PyTorch Segmentation Models Zoo
+All models here were either written from scratch or refactored from open-source implementations.  
+All models here use `Activated Normalization` layers instead of traditional `Normalization` followed by `Activation`. It makes changing activation function and normalization layer easy and convenient. It also allows using [Inplace Activated Batch Norm](https://github.com/mapillary/inplace_abn) from the box, which is essential for reducing memory footprint in segmentation tasks.
+
+
+## Encoders 
+All [models](./pytorch_tools/models/) could be used as feature extractors (aka backbones) for segmentation architectures. Almost all combinations of backbones and segm.model are supported.
+
+
+## Features
+* Unified API. Create `Unet, SegmentaionFPN, HRnet` models using the same code
+* Support for custom number of input channels in pretrained encoders
+* All core functionality covered with tests
+
+
+## Repositories used
+* [Torch Vision Main Repo](https://github.com/pytorch/vision)  
+* [Cadene pretrained models](https://github.com/Cadene/pretrained-models.pytorch/)
+* [Ross Wightman models](https://github.com/rwightman/pytorch-image-models/)
+* [Pytorch Toolbelt by @BloodAxe](https://github.com/BloodAxe/pytorch-toolbelt)  
+* [Segmentation Models py @qubvel](https://github.com/qubvel/segmentation_models.pytorch)  
+* [Original HRNet for Segmentation](https://github.com/HRNet/HRNet-Semantic-Segmentation)
\ No newline at end of file

From ee7e1a71927ba1fedd0b9118b72db487a2220078 Mon Sep 17 00:00:00 2001
From: Emil Zakirov <bonlimezak@gmail.com>
Date: Fri, 8 May 2020 16:01:46 +0300
Subject: [PATCH 12/54] change assert to warning

---
 pytorch_tools/models/densenet.py     |  9 ++++-----
 pytorch_tools/models/efficientnet.py | 10 ++++------
 pytorch_tools/models/hrnet.py        |  9 ++++-----
 pytorch_tools/models/resnet.py       |  9 ++++-----
 pytorch_tools/models/tresnet.py      |  9 ++++-----
 pytorch_tools/models/vgg.py          |  9 ++++-----
 6 files changed, 24 insertions(+), 31 deletions(-)

diff --git a/pytorch_tools/models/densenet.py b/pytorch_tools/models/densenet.py
index 05993b5..bc27ab3 100644
--- a/pytorch_tools/models/densenet.py
+++ b/pytorch_tools/models/densenet.py
@@ -327,11 +327,10 @@ def _densenet(arch, pretrained=None, **kwargs):
         cfg_params.update(pretrained_params)
 
     common_args = set(cfg_params.keys()).intersection(set(kwargs.keys()))
-    assert (
-        common_args == set()
-    ), "Args {} are going to be overwritten by default params for {} weights".format(
-        common_args, pretrained
-    )
+    if common_args:
+        logging.warning(
+            f"Args {common_args} are going to be overwritten by default params for {pretrained} weights"
+        )
     kwargs.update(cfg_params)
     model = DenseNet(**kwargs)
 
diff --git a/pytorch_tools/models/efficientnet.py b/pytorch_tools/models/efficientnet.py
index f4dc720..d2761c7 100644
--- a/pytorch_tools/models/efficientnet.py
+++ b/pytorch_tools/models/efficientnet.py
@@ -402,12 +402,10 @@ def _efficientnet(arch, pretrained=None, **kwargs):
         cfg_settings.update(pretrained_settings)
         cfg_params.update(pretrained_params)
     common_args = set(cfg_params.keys()).intersection(set(kwargs.keys()))
-
-    assert (
-        common_args == set()
-    ), "Args {} are going to be overwritten by default params for {} weights".format(
-        common_args, pretrained
-    )
+    if common_args:
+        logging.warning(
+            f"Args {common_args} are going to be overwritten by default params for {pretrained} weights"
+        )
     kwargs.update(cfg_params)
     model = EfficientNet(**kwargs)
     if pretrained:
diff --git a/pytorch_tools/models/hrnet.py b/pytorch_tools/models/hrnet.py
index 1f7bde6..0a65182 100644
--- a/pytorch_tools/models/hrnet.py
+++ b/pytorch_tools/models/hrnet.py
@@ -381,11 +381,10 @@ def _hrnet(arch, pretrained=None, **kwargs):
         cfg_settings.update(pretrained_settings)
         cfg_params.update(pretrained_params)
     common_args = set(cfg_params.keys()).intersection(set(kwargs.keys()))
-    assert (
-        common_args == set()
-    ), "Args {} are going to be overwritten by default params for {} weights".format(
-        common_args, pretrained
-    )
+    if common_args:
+        logging.warning(
+            f"Args {common_args} are going to be overwritten by default params for {pretrained} weights"
+        )
     kwargs.update(cfg_params)
     model = HighResolutionNet(**kwargs)
     if pretrained:
diff --git a/pytorch_tools/models/resnet.py b/pytorch_tools/models/resnet.py
index 0e396d7..ef4e030 100644
--- a/pytorch_tools/models/resnet.py
+++ b/pytorch_tools/models/resnet.py
@@ -486,11 +486,10 @@ def _resnet(arch, pretrained=None, **kwargs):
         cfg_settings.update(pretrained_settings)
         cfg_params.update(pretrained_params)
     common_args = set(cfg_params.keys()).intersection(set(kwargs.keys()))
-    assert (
-        common_args == set()
-    ), "Args {} are going to be overwritten by default params for {} weights".format(
-        common_args, pretrained
-    )
+    if common_args:
+        logging.warning(
+            f"Args {common_args} are going to be overwritten by default params for {pretrained} weights"
+        )
     kwargs.update(cfg_params)
     model = ResNet(**kwargs)
     if pretrained:
diff --git a/pytorch_tools/models/tresnet.py b/pytorch_tools/models/tresnet.py
index 35063c9..7640e42 100644
--- a/pytorch_tools/models/tresnet.py
+++ b/pytorch_tools/models/tresnet.py
@@ -195,11 +195,10 @@ def _resnet(arch, pretrained=None, **kwargs):
         cfg_settings.update(pretrained_settings)
         cfg_params.update(pretrained_params)
     common_args = set(cfg_params.keys()).intersection(set(kwargs.keys()))
-    assert (
-        common_args == set()
-    ), "Args {} are going to be overwritten by default params for {} weights".format(
-        common_args, pretrained
-    )
+    if common_args:
+        logging.warning(
+            f"Args {common_args} are going to be overwritten by default params for {pretrained} weights"
+        )
     kwargs.update(cfg_params)
     model = TResNet(**kwargs)
     if pretrained:
diff --git a/pytorch_tools/models/vgg.py b/pytorch_tools/models/vgg.py
index 41004cf..b2037ce 100644
--- a/pytorch_tools/models/vgg.py
+++ b/pytorch_tools/models/vgg.py
@@ -170,11 +170,10 @@ def _vgg(arch, pretrained=None, **kwargs):
         cfg_settings.update(pretrained_settings)
         cfg_params.update(pretrained_params)
     common_args = set(cfg_params.keys()).intersection(set(kwargs.keys()))
-    assert (
-        common_args == set()
-    ), "Args {} are going to be overwritten by default params for {} weights".format(
-        common_args, pretrained or "default"
-    )
+    if common_args:
+        logging.warning(
+            f"Args {common_args} are going to be overwritten by default params for {pretrained} weights"
+        )
     kwargs.update(cfg_params)
     model = VGG(**kwargs)
     if pretrained:

From ee41bdcbb8c0c7b001c4e8bc507a12ff0e6e45a0 Mon Sep 17 00:00:00 2001
From: Emil Zakirov <bonlimezak@gmail.com>
Date: Sat, 9 May 2020 01:59:39 +0300
Subject: [PATCH 13/54] fix bug for RMSprop

---
 pytorch_tools/optim/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pytorch_tools/optim/__init__.py b/pytorch_tools/optim/__init__.py
index fc06bbe..bcd9e6d 100644
--- a/pytorch_tools/optim/__init__.py
+++ b/pytorch_tools/optim/__init__.py
@@ -25,7 +25,7 @@ def optimizer_from_name(optim_name):
         # in this implementation eps in inside sqrt so it can be smaller
         return partial(AdamW_my, center=True, eps=1e-7)
     elif optim_name == "rmsprop":
-        return partial(optim.RMSprop, 2e-5)
+        return partial(optim.RMSprop, eps=2e-5)
     elif optim_name == "radam":
         return partial(RAdam, eps=2e-5)
     elif optim_name in ["fused_sgd", "fusedsgd"]:

From c906cf2da2b312e5ba1ba02c88f610f58c98a8c0 Mon Sep 17 00:00:00 2001
From: Emil Zakirov <bonlimezak@gmail.com>
Date: Mon, 11 May 2020 18:51:07 +0300
Subject: [PATCH 14/54] support output stride in decoder. remove `initialize`
 for decoders

---
 pytorch_tools/modules/decoder.py              |  5 +++--
 pytorch_tools/segmentation_models/hrnet.py    |  3 ++-
 pytorch_tools/segmentation_models/linknet.py  |  3 ++-
 pytorch_tools/segmentation_models/segm_fpn.py |  4 ----
 pytorch_tools/segmentation_models/unet.py     | 17 +++++++++++------
 5 files changed, 18 insertions(+), 14 deletions(-)

diff --git a/pytorch_tools/modules/decoder.py b/pytorch_tools/modules/decoder.py
index 731cdb5..af9412b 100644
--- a/pytorch_tools/modules/decoder.py
+++ b/pytorch_tools/modules/decoder.py
@@ -7,7 +7,7 @@
 
 
 class UnetDecoderBlock(nn.Module):
-    def __init__(self, in_channels, out_channels, norm_layer=ABN, norm_act="relu"):
+    def __init__(self, in_channels, out_channels, norm_layer=ABN, norm_act="relu", upsample=True):
         super(UnetDecoderBlock, self).__init__()
 
         conv1 = conv3x3(in_channels, out_channels)
@@ -15,10 +15,11 @@ def __init__(self, in_channels, out_channels, norm_layer=ABN, norm_act="relu"):
         abn1 = norm_layer(out_channels, activation=norm_act)
         abn2 = norm_layer(out_channels, activation=norm_act)
         self.block = nn.Sequential(conv1, abn1, conv2, abn2)
+        self.upsample = nn.Upsample(scale_factor=2, mode="bilinear") if upsample else nn.Identity()
 
     def forward(self, x):
         x, skip = x
-        x = F.interpolate(x, scale_factor=2, mode="nearest")
+        x = self.upsample(x)
         if skip is not None:
             x = torch.cat([x, skip], dim=1)
         x = self.block(x)
diff --git a/pytorch_tools/segmentation_models/hrnet.py b/pytorch_tools/segmentation_models/hrnet.py
index a763849..9690ea9 100644
--- a/pytorch_tools/segmentation_models/hrnet.py
+++ b/pytorch_tools/segmentation_models/hrnet.py
@@ -112,7 +112,8 @@ def __init__(
         self.name = f"segm-{encoder_name}"
         # use lower momemntum 
         patch_bn_mom(self)
-        self._init_weights()
+        # works better without init (for some reason)
+        # self._init_weights()
 
     def forward(self, x):
         """Sequentially pass `x` trough model`s `encoder` and `head` (return logits!)"""
diff --git a/pytorch_tools/segmentation_models/linknet.py b/pytorch_tools/segmentation_models/linknet.py
index 53a8e99..e755c41 100644
--- a/pytorch_tools/segmentation_models/linknet.py
+++ b/pytorch_tools/segmentation_models/linknet.py
@@ -22,7 +22,8 @@ def __init__(
         self.dropout = nn.Dropout2d(drop_rate, inplace=True)
         self.final_conv = conv1x1(prefinal_channels, final_channels)
 
-        initialize(self)
+        # it works much better without initializing decoder. maybe need to investigate into this issue
+        # initialize(self)
 
     def forward(self, x):
         encoder_head = x[0]
diff --git a/pytorch_tools/segmentation_models/segm_fpn.py b/pytorch_tools/segmentation_models/segm_fpn.py
index 46cd152..bc73518 100644
--- a/pytorch_tools/segmentation_models/segm_fpn.py
+++ b/pytorch_tools/segmentation_models/segm_fpn.py
@@ -6,7 +6,6 @@
 from pytorch_tools.modules.residual import conv1x1
 from pytorch_tools.modules.residual import conv3x3
 from pytorch_tools.modules.decoder import SegmentationUpsample
-from pytorch_tools.utils.misc import initialize
 from .encoders import get_encoder
 
 
@@ -114,9 +113,6 @@ def __init__(
         self.segm_head = conv1x1(segmentation_channels, num_classes)
         self.upsample = nn.Upsample(scale_factor=4, mode="bilinear") if last_upsample else nn.Identity()
         self.name = f"segm-fpn-{encoder_name}"
-        initialize(self.fpn)
-        initialize(self.decoder)
-        initialize(self.segm_head)
 
     def forward(self, x):
         x = self.encoder(x) # returns 5 features maps
diff --git a/pytorch_tools/segmentation_models/unet.py b/pytorch_tools/segmentation_models/unet.py
index d784e37..42eae40 100644
--- a/pytorch_tools/segmentation_models/unet.py
+++ b/pytorch_tools/segmentation_models/unet.py
@@ -1,6 +1,7 @@
 import torch.nn as nn
 from pytorch_tools.modules import bn_from_name
 from pytorch_tools.modules.residual import conv1x1
+from pytorch_tools.modules.residual import conv3x3
 from pytorch_tools.modules.decoder import UnetDecoderBlock
 from pytorch_tools.utils.misc import initialize
 from .base import EncoderDecoder
@@ -20,6 +21,7 @@ def __init__(
         final_channels=1,
         center=False,
         drop_rate=0,
+        output_stride=32,
         **bn_params,  # norm layer, norm_act
     ):
 
@@ -32,16 +34,15 @@ def __init__(
 
         in_channels = self.compute_channels(encoder_channels, decoder_channels)
         out_channels = decoder_channels
-
-        self.layer1 = UnetDecoderBlock(in_channels[0], out_channels[0], **bn_params)
-        self.layer2 = UnetDecoderBlock(in_channels[1], out_channels[1], **bn_params)
+        self.layer1 = UnetDecoderBlock(in_channels[0], out_channels[0], upsample=output_stride == 32, **bn_params)
+        self.layer2 = UnetDecoderBlock(in_channels[1], out_channels[1], upsample=not output_stride == 8, **bn_params)
         self.layer3 = UnetDecoderBlock(in_channels[2], out_channels[2], **bn_params)
         self.layer4 = UnetDecoderBlock(in_channels[3], out_channels[3], **bn_params)
         self.layer5 = UnetDecoderBlock(in_channels[4], out_channels[4], **bn_params)
         self.dropout = nn.Dropout2d(drop_rate, inplace=False) # inplace=True raises a backprop error
         self.final_conv = conv1x1(out_channels[4], final_channels)
-
-        initialize(self)
+        # it works much better without initializing decoder. maybe need to investigate into this issue
+        # initialize(self)
 
     def compute_channels(self, encoder_channels, decoder_channels):
         channels = [
@@ -97,11 +98,14 @@ def __init__(
         decoder_channels=(256, 128, 64, 32, 16),
         num_classes=1,
         center=False,  # usefull for VGG models
+        output_stride=32,
         drop_rate=0,
         norm_layer="abn",
         norm_act="relu",
         **encoder_params,
-    ):
+    ):  
+        if output_stride != 32:
+            encoder_params["output_stride"] = output_stride
         encoder = get_encoder(
             encoder_name,
             norm_layer=norm_layer,
@@ -115,6 +119,7 @@ def __init__(
             final_channels=num_classes,
             center=center,
             drop_rate=drop_rate,
+            output_stride=output_stride,
             norm_layer=bn_from_name(norm_layer),
             norm_act=norm_act,
         )

From 5f37b9928fabbb3ac732b385b59bc0d2babbfe39 Mon Sep 17 00:00:00 2001
From: Emil Zakirov <bonlimezak@gmail.com>
Date: Tue, 12 May 2020 20:44:58 +0300
Subject: [PATCH 15/54] fix bug with biad in WS

---
 pytorch_tools/modules/weight_standartization.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pytorch_tools/modules/weight_standartization.py b/pytorch_tools/modules/weight_standartization.py
index 5f8e926..0ad0f9f 100644
--- a/pytorch_tools/modules/weight_standartization.py
+++ b/pytorch_tools/modules/weight_standartization.py
@@ -35,7 +35,7 @@ def conv_to_ws_conv(module):
             with torch.no_grad(): # not sure if torch.no_grad is needed. but just in case
                 module_output.weight.copy_(module.weight)
                 module_output.weight.requires_grad = module.weight.requires_grad
-                if module.bias:
+                if module.bias is not None:
                     module_output.bias.copy_(module.bias)
                     module_output.bias.requires_grad = module.bias.requires_grad
 

From 128f07482ca9e57de47d6035be80b52ec1ce32ef Mon Sep 17 00:00:00 2001
From: Emil Zakirov <bonlimezak@gmail.com>
Date: Wed, 13 May 2020 11:25:37 +0300
Subject: [PATCH 16/54] add tests for WS

---
 .../modules/weight_standartization.py         |  2 +-
 tests/modules/test_activations.py             | 19 ------------
 tests/modules/test_modules.py                 | 29 +++++++++++++++++++
 3 files changed, 30 insertions(+), 20 deletions(-)
 delete mode 100644 tests/modules/test_activations.py
 create mode 100644 tests/modules/test_modules.py

diff --git a/pytorch_tools/modules/weight_standartization.py b/pytorch_tools/modules/weight_standartization.py
index 0ad0f9f..a250524 100644
--- a/pytorch_tools/modules/weight_standartization.py
+++ b/pytorch_tools/modules/weight_standartization.py
@@ -30,7 +30,7 @@ def conv_to_ws_conv(module):
                 # groups are also present in DepthWiseConvs which we don't want to patch
                 # TODO: fix this
                 groups=module.groups, 
-                bias=module.bias,
+                bias=module.bias is not None,
             )
             with torch.no_grad(): # not sure if torch.no_grad is needed. but just in case
                 module_output.weight.copy_(module.weight)
diff --git a/tests/modules/test_activations.py b/tests/modules/test_activations.py
deleted file mode 100644
index 1f2a9a9..0000000
--- a/tests/modules/test_activations.py
+++ /dev/null
@@ -1,19 +0,0 @@
-import torch
-import pytest
-import pytorch_tools.modules as modules
-
-activations_name = ["Swish", "Swish_Naive", "Mish", "Mish_naive"]
-
-
-@pytest.mark.parametrize("activation", activations_name)
-def test_activations_init(activation):
-    inp = torch.ones(10)
-    act = modules.activation_from_name(activation)
-    res = act(inp)
-    assert res.mean()
-
-def test_frozen_abn():
-    l = modules.bn_from_name("frozen_abn")(10)
-    assert list(l.parameters()) == []
-    l = modules.ABN(10, frozen=True)
-    assert list(l.parameters()) == []
\ No newline at end of file
diff --git a/tests/modules/test_modules.py b/tests/modules/test_modules.py
new file mode 100644
index 0000000..969adc0
--- /dev/null
+++ b/tests/modules/test_modules.py
@@ -0,0 +1,29 @@
+import torch
+import pytest
+import pytorch_tools as pt
+import pytorch_tools.modules as modules
+
+activations_name = ["Swish", "Swish_Naive", "Mish", "Mish_naive"]
+
+
+@pytest.mark.parametrize("activation", activations_name)
+def test_activations_init(activation):
+    inp = torch.ones(10)
+    act = modules.activation_from_name(activation)
+    res = act(inp)
+    assert res.mean()
+
+def test_frozen_abn():
+    l = modules.bn_from_name("frozen_abn")(10)
+    assert list(l.parameters()) == []
+    l = modules.ABN(10, frozen=True)
+    assert list(l.parameters()) == []
+
+# need to test and resnet and vgg because in resnet there are no Convs with bias
+# and in VGG there are no Convs without bias
+@pytest.mark.parametrize("norm_layer", ["abn", "agn"])
+@pytest.mark.parametrize("arch", ["resnet18", "vgg11_bn"])
+def test_weight_standardization(norm_layer, arch):
+    m = pt.models.__dict__[arch](norm_layer=norm_layer)
+    ws_m = modules.weight_standartization.conv_to_ws_conv(m)
+    out = ws_m(torch.ones(2, 3, 224, 224))

From 7cf13d763e4b80ad56a80b85ec7aeba1965d6c1b Mon Sep 17 00:00:00 2001
From: Emil Zakirov <bonlimezak@gmail.com>
Date: Wed, 13 May 2020 19:09:58 +0300
Subject: [PATCH 17/54] remove pool type selection (makes it ~1% faster)

---
 pytorch_tools/models/resnet.py | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/pytorch_tools/models/resnet.py b/pytorch_tools/models/resnet.py
index ef4e030..ed9c4b7 100644
--- a/pytorch_tools/models/resnet.py
+++ b/pytorch_tools/models/resnet.py
@@ -17,6 +17,7 @@
 from pytorch_tools.modules import BasicBlock, Bottleneck
 from pytorch_tools.modules import GlobalPool2d, BlurPool
 from pytorch_tools.modules.residual import conv1x1, conv3x3
+from pytorch_tools.modules.pooling import FastGlobalAvgPool2d
 from pytorch_tools.modules import bn_from_name
 from pytorch_tools.utils.misc import add_docs_for
 from pytorch_tools.utils.misc import DEFAULT_IMAGENET_SETTINGS
@@ -74,8 +75,6 @@ class ResNet(nn.Module):
         drop_connect_rate (float):
             Drop rate for StochasticDepth. Randomly removes samples each block. Used as regularization during training. 
             keep prob will be linearly decreased from 1 to 1 - drop_connect_rate each block. Ref: https://arxiv.org/abs/1603.09382
-        global_pool (str):
-            Global pooling type. One of 'avg', 'max', 'avgmax', 'catavgmax'. Defaults to 'avg'.
         init_bn0 (bool):
             Zero-initialize the last BN in each residual branch, so that the residual
             branch starts with zeros, and each residual block behaves like an identity.
@@ -100,7 +99,6 @@ def __init__(
         encoder=False,
         drop_rate=0.0,
         drop_connect_rate=0.0,
-        global_pool="avg",
         init_bn0=True,
     ):
 
@@ -145,12 +143,12 @@ def __init__(
         self.layer2 = self._make_layer(128, layers[1], stride=2, **largs)
         self.layer3 = self._make_layer(256, layers[2], stride=stride_3, dilation=dilation_3, **largs)
         self.layer4 = self._make_layer(512, layers[3], stride=stride_4, dilation=dilation_4, **largs)
-        self.global_pool = GlobalPool2d(global_pool)
+        self.global_pool = FastGlobalAvgPool2d()
         self.num_features = 512 * self.expansion
         self.encoder = encoder
         if not encoder:
             self.dropout = nn.Dropout(p=drop_rate, inplace=True)
-            self.last_linear = nn.Linear(self.num_features * self.global_pool.feat_mult(), num_classes)
+            self.last_linear = nn.Linear(self.num_features, num_classes)
         else:
             self.forward = self.encoder_features
 

From 247e725bd49145ed820e4cae1a721c67189b0e55 Mon Sep 17 00:00:00 2001
From: Emil Zakirov <bonlimezak@gmail.com>
Date: Wed, 13 May 2020 20:48:40 +0300
Subject: [PATCH 18/54] add polunomial decay to PhasesScheduler

---
 pytorch_tools/fit_wrapper/callbacks.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/pytorch_tools/fit_wrapper/callbacks.py b/pytorch_tools/fit_wrapper/callbacks.py
index 57eacc8..37526eb 100644
--- a/pytorch_tools/fit_wrapper/callbacks.py
+++ b/pytorch_tools/fit_wrapper/callbacks.py
@@ -135,7 +135,7 @@ def on_loader_end(self):
 class PhasesScheduler(Callback):
     """
     Scheduler that uses `phases` to process updates.
-    Supported `mode`'s are {`linear`, `cos`}
+    Supported `mode`'s are {`linear`, `cos`, `poly`}
 
     Args:
         phases (List[Dict]): phases
@@ -175,6 +175,9 @@ def _schedule(start, end, pct, mode):
             return start + (end - start) * pct
         elif mode == "cos":
             return end + (start - end) / 2 * (math.cos(math.pi * pct) + 1)
+        elif mode == "poly":
+            gamma = (end / start) ** (1 / 100)
+            return start * gamma ** (pct * 100)
         else:
             raise ValueError(f"Mode: `{mode}` is not supported in PhasesScheduler")
 

From 5b267cc1d509ad996d0cb7c19432344048a9ec0b Mon Sep 17 00:00:00 2001
From: Emil Zakirov <bonlimezak@gmail.com>
Date: Thu, 14 May 2020 19:16:06 +0300
Subject: [PATCH 19/54] add ModelEMA

---
 pytorch_tools/fit_wrapper/callbacks.py | 67 +++++++++++++++++++++++++-
 tests/fit_wrapper/test_runner.py       |  1 +
 2 files changed, 67 insertions(+), 1 deletion(-)

diff --git a/pytorch_tools/fit_wrapper/callbacks.py b/pytorch_tools/fit_wrapper/callbacks.py
index 37526eb..d38e3bd 100644
--- a/pytorch_tools/fit_wrapper/callbacks.py
+++ b/pytorch_tools/fit_wrapper/callbacks.py
@@ -3,6 +3,7 @@
 import logging
 from tqdm import tqdm
 from enum import Enum
+from copy import deepcopy
 from collections import OrderedDict
 from collections import defaultdict
 import numpy as np
@@ -707,4 +708,68 @@ def on_epoch_end(self):
                 self.state.optimizer.state = defaultdict(dict)
                 
             if self.verbose:
-                print("Reseting optimizer")
\ No newline at end of file
+                print("Reseting optimizer")
+
+# docstring from https://github.com/rwightman/pytorch-image-models
+class ModelEma(Callback):
+    """ Model Exponential Moving Average
+    Keeps a moving average of everything in the model state_dict (parameters and buffers).
+    This is intended to allow functionality like
+    https://www.tensorflow.org/api_docs/python/tf/train/ExponentialMovingAverage
+
+    A smoothed version of the weights is necessary for some training schemes to perform well.
+    E.g. Google's hyper-params for training MNASNet, MobileNet-V3, EfficientNet, etc that use
+    RMSprop with a short 2.4-3 epoch decay period and slow LR decay rate of .96-.99 requires EMA
+    smoothing of weights to match results. 
+    
+    Current implementation follows TensorFlow and uses the following formula:
+    ema -= (1 - decay) * (ema - model)
+    This is mathematically equivalent to the classic formula below but inplace is faster
+    ema = decay * ema + (1 - decay) * model
+
+    NOTE: Pay attention to the decay constant you are using relative to your update count per epoch.
+    
+    NOTE: put this Callback AFTER Checkpoint saver! Otherwise you would validate EMA weights but save
+    model weights
+
+    NOTE: Only need to be used in master process! otherwise it would take extra memory on all GPUs
+
+    NOTE: Pass model to ModelEma after cuda() and AMP but before SyncBN and DDP wrapper
+
+    Args:
+        model (nn.Module): model after cuda and AMP
+        decay (float): decay for EMA for every step
+        decay_every (int): how oftern to really decay weights. Decaying every step produced a 
+            visible training slowdown. Real decay factor is adjusted to match every step update.
+    """
+    def __init__(self, model, decay=0.9999, decay_every=10):
+        super().__init__()
+        self.ema = deepcopy(model).eval()    
+        for p in self.ema.parameters():
+            p.requires_grad_(False)
+        self.model_copy = None
+        self.decay_factor = 1 - decay ** decay_every # simulate every step decay
+        self.decay_every = decay_every
+
+    def on_batch_end(self):
+        if not self.state.is_train or (self.state.step % self.decay_every != 0):
+            return
+
+        with torch.no_grad():
+            for (ema_v, m_v) in zip(self.ema.state_dict().values(), self.state.model.state_dict().values()):
+                if m_v.numel() == 1: # to prevent errors on `num_batches_tracked` in BN
+                    continue 
+                ema_v.sub_(ema_v.sub(m_v), alpha=self.decay_factor)
+
+    def on_loader_begin(self):
+        if self.state.is_train:
+           return
+        # validate on ema model
+        self.model_copy = self.state.model
+        self.state.model = self.ema
+        
+    def on_epoch_end(self):
+        if self.state.is_train:
+           return
+        # return model back
+        self.state.model = self.model_copy
\ No newline at end of file
diff --git a/tests/fit_wrapper/test_runner.py b/tests/fit_wrapper/test_runner.py
index b600d37..6dd56ca 100644
--- a/tests/fit_wrapper/test_runner.py
+++ b/tests/fit_wrapper/test_runner.py
@@ -133,6 +133,7 @@ def test_grad_clip_loader():
         pt_clb.Mixup(0.2, NUM_CLASSES),
         pt_clb.Cutmix(1.0, NUM_CLASSES),
         pt_clb.ScheduledDropout(),
+        pt_clb.ModelEma(decay=0.9999)
     ],
 )
 def test_callback(callback):

From c4479d45e98e0a3be44b0781bb78cf0b0f3a2198 Mon Sep 17 00:00:00 2001
From: Emil Zakirov <bonlimezak@gmail.com>
Date: Fri, 15 May 2020 14:22:55 +0300
Subject: [PATCH 20/54] make BlurPool use GaussBlur instead of AvgBlur by
 default

---
 pytorch_tools/models/tresnet.py  |  8 --------
 pytorch_tools/modules/pooling.py | 21 +++++++--------------
 2 files changed, 7 insertions(+), 22 deletions(-)

diff --git a/pytorch_tools/models/tresnet.py b/pytorch_tools/models/tresnet.py
index 7640e42..532cab5 100644
--- a/pytorch_tools/models/tresnet.py
+++ b/pytorch_tools/models/tresnet.py
@@ -171,12 +171,6 @@ def load_state_dict(self, state_dict, **kwargs):
     },
 }
 # fmt: on
-def patch_blur_pool(module):
-    """changes `gauss` attribute in blur pool to True"""
-    if isinstance(module, BlurPool):
-        module.gauss = True    
-    for m in module.children():
-        patch_blur_pool(m)
 
 def patch_bn(module):
     """changes weight from InplaceABN to be compatible with usual ABN"""
@@ -216,8 +210,6 @@ def _resnet(arch, pretrained=None, **kwargs):
         if kwargs.get("in_channels", 3) != 3: # support pretrained for custom input channels
             state_dict["conv1.1.weight"] = repeat_channels(state_dict["conv1.1.weight"], kwargs["in_channels"] * 16, 3 * 16)
         model.load_state_dict(state_dict)
-        # need to adjust some parameters to be align with original model
-        patch_blur_pool(model)
         patch_bn(model)
     setattr(model, "pretrained_settings", cfg_settings)
     return model
diff --git a/pytorch_tools/modules/pooling.py b/pytorch_tools/modules/pooling.py
index 34ee24d..0e8c24d 100644
--- a/pytorch_tools/modules/pooling.py
+++ b/pytorch_tools/modules/pooling.py
@@ -81,30 +81,23 @@ def forward(self, x):
 class BlurPool(nn.Module):
     """
     Idea from https://arxiv.org/abs/1904.11486
-    Efficient implementation of Rect-3 using AvgPool
+    Efficient implementation of Rect-3
     Args:
-        channels (int): numbers of channels. needed for gaussian blur
-        gauss (bool): flag to use Gaussian Blur instead of Average Blur. Uses more memory
+        channels (int): numbers of input channels. needed to construct gauss kernel
     """
 
-    def __init__(self, channels=0, gauss=False):
+    def __init__(self, channels=0):
         super(BlurPool, self).__init__()
-        self.gauss = gauss
         self.channels = channels
-        # init both options to be able to switch
-        a = torch.tensor([1., 2., 1.])
-        filt = (a[:, None] * a[None, :]).clone().detach()
+        filt = torch.tensor([1., 2., 1.])
+        filt = filt[:, None] * filt[None, :]
         filt = filt / torch.sum(filt)
         filt = filt[None, None, :, :].repeat((self.channels, 1, 1, 1))
         self.register_buffer("filt", filt)
-        self.pool = nn.AvgPool2d(3, stride=2, padding=1)
 
     def forward(self, inp):
-        if self.gauss:
-            inp_pad = F.pad(inp, (1, 1, 1, 1), 'reflect')
-            return F.conv2d(inp_pad, self.filt, stride=2, padding=0, groups=inp.shape[1])
-        else:
-            return self.pool(inp)
+        inp_pad = F.pad(inp, (1, 1, 1, 1), 'reflect')
+        return F.conv2d(inp_pad, self.filt, stride=2, padding=0, groups=inp.shape[1])
 
 # from https://github.com/mrT23/TResNet/
 class SpaceToDepth(nn.Module):

From c716834432e5b22a367a2daea994fe6b455fc179 Mon Sep 17 00:00:00 2001
From: Emil Zakirov <bonlimezak@gmail.com>
Date: Fri, 15 May 2020 20:25:18 +0300
Subject: [PATCH 21/54] add Efficient Channel Attention

---
 pytorch_tools/models/efficientnet.py |  2 +-
 pytorch_tools/models/resnet.py       | 32 ++++-----
 pytorch_tools/models/tresnet.py      |  4 +-
 pytorch_tools/modules/residual.py    | 97 +++++++++++++++++-----------
 4 files changed, 79 insertions(+), 56 deletions(-)

diff --git a/pytorch_tools/models/efficientnet.py b/pytorch_tools/models/efficientnet.py
index d2761c7..7e01a35 100644
--- a/pytorch_tools/models/efficientnet.py
+++ b/pytorch_tools/models/efficientnet.py
@@ -234,7 +234,7 @@ def _decode_block_string(block_string):
         out_channels=int(options["o"]),
         dw_kernel_size=int(options["k"]),
         stride=tuple([options["s"], options["s"]]),
-        use_se=float(options["se"]) > 0 if "se" in options else False,
+        attn_type="se" if "se" in options else None,
         expand_ratio=int(options["e"]),
         noskip="noskip" in block_string,
         num_repeat=int(options["r"]),
diff --git a/pytorch_tools/models/resnet.py b/pytorch_tools/models/resnet.py
index ed9c4b7..88a562c 100644
--- a/pytorch_tools/models/resnet.py
+++ b/pytorch_tools/models/resnet.py
@@ -50,8 +50,10 @@ class ResNet(nn.Module):
             Number of classification classes. Defaults to 1000.
         in_channels (int):
             Number of input (color) channels. Defaults to 3.
-        use_se (bool):
-            Enable Squeeze-Excitation module in blocks.
+        attn_type (Union[str, None]):
+            If given, selects attention type to use in blocks. One of 
+            `se` - Squeeze-Excitation
+            `eca` - Efficient Channel Attention
         groups (int):
             Number of convolution groups for 3x3 conv in Bottleneck. Defaults to 1.
         base_width (int):
@@ -88,7 +90,7 @@ def __init__(
         pretrained=None,  # not used. here for proper signature
         num_classes=1000,
         in_channels=3,
-        use_se=False,
+        attn_type=None,
         groups=1,
         base_width=64,
         deep_stem=False,
@@ -127,9 +129,7 @@ def __init__(
         else:
             self.conv1 = nn.Conv2d(in_channels, stem_width, kernel_size=7, stride=2, padding=3, bias=False)
         self.bn1 = norm_layer(stem_width, activation=norm_act)
-        self.maxpool = nn.MaxPool2d(
-            kernel_size=3, stride=2, padding=0 if use_se else 1, ceil_mode=True if use_se else False,
-        )
+        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
         if output_stride not in [8, 16, 32]:
             raise ValueError("Output stride should be in [8, 16, 32]")
         if output_stride == 8:
@@ -138,7 +138,7 @@ def __init__(
             stride_3, stride_4, dilation_3, dilation_4 = 2, 1, 1, 2
         elif output_stride == 32:
             stride_3, stride_4, dilation_3, dilation_4 = 2, 2, 1, 1
-        largs = dict(use_se=use_se, norm_layer=norm_layer, norm_act=norm_act, antialias=antialias)
+        largs = dict(attn_type=attn_type, norm_layer=norm_layer, norm_act=norm_act, antialias=antialias)
         self.layer1 = self._make_layer(64, layers[0], stride=1, **largs)
         self.layer2 = self._make_layer(128, layers[1], stride=2, **largs)
         self.layer3 = self._make_layer(256, layers[2], stride=stride_3, dilation=dilation_3, **largs)
@@ -160,7 +160,7 @@ def _make_layer(
         blocks,
         stride=1,
         dilation=1,
-        use_se=None,
+        attn_type=None,
         norm_layer=None,
         norm_act=None,
         antialias=None,
@@ -186,7 +186,7 @@ def _make_layer(
                 downsample=downsample,
                 groups=self.groups,
                 base_width=self.base_width,
-                use_se=use_se,
+                attn_type=attn_type,
                 dilation=first_dilation,
                 norm_layer=norm_layer,
                 norm_act=norm_act,
@@ -203,7 +203,7 @@ def _make_layer(
                     planes=planes,
                     groups=self.groups,
                     base_width=self.base_width,
-                    use_se=use_se,
+                    attn_type=attn_type,
                     dilation=first_dilation,
                     norm_layer=norm_layer,
                     norm_act=norm_act,
@@ -417,28 +417,28 @@ def keep_prob(self):
     # SE RESNET MODELS
     "se_resnet34": {
         "default": {
-            "params": {"block": BasicBlock, "layers": [3, 4, 6, 3], "use_se": True},
+            "params": {"block": BasicBlock, "layers": [3, 4, 6, 3], "attn_type": "se"},
             **DEFAULT_IMAGENET_SETTINGS,
         },
         # NO WEIGHTS
     },
     "se_resnet50": {
         "default": {
-            "params": {"block": Bottleneck, "layers": [3, 4, 6, 3], "use_se": True},
+            "params": {"block": Bottleneck, "layers": [3, 4, 6, 3], "attn_type": "se"},
             **DEFAULT_IMAGENET_SETTINGS,
         },
         "imagenet": {"url": "http://data.lip6.fr/cadene/pretrainedmodels/se_resnet50-ce0d4300.pth"},
     },
     "se_resnet101": {
         "default": {
-            "params": {"block": Bottleneck, "layers": [3, 4, 23, 3], "use_se": True},
+            "params": {"block": Bottleneck, "layers": [3, 4, 23, 3], "attn_type": "se"},
             **DEFAULT_IMAGENET_SETTINGS,
         },
         "imagenet": {"url": "http://data.lip6.fr/cadene/pretrainedmodels/se_resnet101-7e38fcc6.pth"},
     },
     "se_resnet152": {
         "default": {
-            "params": {"block": Bottleneck, "layers": [3, 4, 36, 3], "use_se": True},
+            "params": {"block": Bottleneck, "layers": [3, 4, 36, 3], "attn_type": "se"},
             **DEFAULT_IMAGENET_SETTINGS,
         },
         "imagenet": {"url": "http://data.lip6.fr/cadene/pretrainedmodels/se_resnet152-d17c99b7.pth"},
@@ -451,7 +451,7 @@ def keep_prob(self):
                 "layers": [3, 4, 6, 3],
                 "base_width": 4,
                 "groups": 32,
-                "use_se": True,
+                "attn_type": "se",
             },
             **DEFAULT_IMAGENET_SETTINGS,
         },
@@ -464,7 +464,7 @@ def keep_prob(self):
                 "layers": [3, 4, 23, 3],
                 "base_width": 4,
                 "groups": 32,
-                "use_se": True,
+                "attn_type": "se",
             },
             **DEFAULT_IMAGENET_SETTINGS,
         },
diff --git a/pytorch_tools/models/tresnet.py b/pytorch_tools/models/tresnet.py
index 532cab5..52849f7 100644
--- a/pytorch_tools/models/tresnet.py
+++ b/pytorch_tools/models/tresnet.py
@@ -98,7 +98,7 @@ def __init__(
         # elif output_stride == 32:
         stride_3, stride_4, dilation_3, dilation_4 = 2, 2, 1, 1
 
-        largs = dict(use_se=True, norm_layer=norm_layer, norm_act=norm_act, antialias=True)
+        largs = dict(attn_type="se", norm_layer=norm_layer, norm_act=norm_act, antialias=True)
         self.block = TBasicBlock
         self.expansion = TBasicBlock.expansion
         self.layer1 = self._make_layer(stem_width, layers[0], stride=1, **largs)
@@ -107,7 +107,7 @@ def __init__(
         self.block = TBottleneck # first 2 - Basic, last 2 - Bottleneck
         self.expansion = TBottleneck.expansion
         self.layer3 = self._make_layer(stem_width * 4, layers[2], stride=stride_3, dilation=dilation_3, **largs)
-        largs.update(use_se=False) # no se in last layer
+        largs.update(attn_type=None) # no se in last layer
         self.layer4 = self._make_layer(stem_width * 8, layers[3], stride=stride_4, dilation=dilation_4, **largs)
         self.global_pool = FastGlobalAvgPool2d(flatten=True)
         self.num_features = stem_width * 8 * self.expansion
diff --git a/pytorch_tools/modules/residual.py b/pytorch_tools/modules/residual.py
index c8da1f4..a614ebb 100644
--- a/pytorch_tools/modules/residual.py
+++ b/pytorch_tools/modules/residual.py
@@ -30,6 +30,55 @@ def conv1x1(in_planes, out_planes, stride=1, bias=False):
     return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=bias)
 
 
+class SEModule(nn.Module):
+    def __init__(self, channels, reduction_channels, norm_act="relu"):
+        super(SEModule, self).__init__()
+
+        self.pool = FastGlobalAvgPool2d()
+        # authors of original paper DO use bias
+        self.fc1 = nn.Conv2d(channels, reduction_channels, kernel_size=1, stride=1, bias=True)
+        self.act1 = activation_from_name(norm_act)
+        self.fc2 = nn.Conv2d(reduction_channels, channels, kernel_size=1, stride=1, bias=True)
+
+    def forward(self, x):
+        x_se = self.pool(x)
+        x_se = self.fc1(x_se)
+        x_se = self.act1(x_se)
+        x_se = self.fc2(x_se)
+        return x * x_se.sigmoid()
+
+class ECAModule(nn.Module):
+    """Efficient Channel Attention
+    This implementation is different from the paper. I've removed all hyperparameters and 
+    use fixed kernel size of 3. If you think it may be better to use different k_size - feel free to open an issue. 
+
+    Ref: ECA-Net: Efficient Channel Attention for Deep Convolutional Neural Networks
+    https://arxiv.org/abs/1910.03151
+
+    """
+    def __init__(self, *args, **kwargs): 
+        super().__init__()
+        self.pool = FastGlobalAvgPool2d()
+        self.conv = nn.Conv1d(1, 1, kernel_size=3, padding=1, bias=False)
+
+    def forward(self, x):
+        x_s = self.pool(x)
+        x_s = self.conv(x_s.view(x.size(0), 1, -1))
+        x_s = x_s.view(x.size(0), -1, 1, 1).sigmoid()
+        return x * x_s.expand_as(x)
+
+def get_attn(attn_type):
+    """Args: attn_type (Uniont[str, None]): Attention type. Supported:
+        `se` - Squeeze and Excitation
+        `eca` - Efficient Channel Attention
+        None - not attention
+    """
+    ATT_TO_MODULE = {"se": SEModule, "eca": ECAModule}
+    if attn_type is None:
+        return nn.Identity
+    else:
+        return ATT_TO_MODULE[attn_type.lower()]
+
 class DepthwiseSeparableConv(nn.Sequential):
     """Depthwise separable conv with BN after depthwise & pointwise."""
 
@@ -50,7 +99,7 @@ def __init__(
         dw_kernel_size=3,
         stride=1,
         dilation=1,
-        use_se=False,
+        attn_type=None,
         expand_ratio=1.0,  # expansion
         keep_prob=1,  # drop connect param
         noskip=False,
@@ -77,7 +126,7 @@ def __init__(
         )
         self.bn2 = norm_layer(mid_chs, activation=norm_act)
         # some models like MobileNet use mid_chs here instead of in_channels. But I don't care for now
-        self.se = SEModule(mid_chs, in_channels // 4, norm_act) if use_se else nn.Identity()
+        self.se = get_attn(attn_type)(mid_chs, in_channels // 4, norm_act)
         self.conv_pw1 = conv1x1(mid_chs, out_channels)
         self.bn3 = norm_layer(out_channels, activation="identity")
         self.drop_connect = DropConnect(keep_prob) if keep_prob < 1 else nn.Identity()
@@ -116,25 +165,6 @@ def forward(self, x):
         output = x / self.keep_prob * binary_tensor
         return output
 
-
-class SEModule(nn.Module):
-    def __init__(self, channels, reduction_channels, norm_act="relu"):
-        super(SEModule, self).__init__()
-
-        self.pool = FastGlobalAvgPool2d()
-        # authors of original paper DO use bias
-        self.fc1 = nn.Conv2d(channels, reduction_channels, kernel_size=1, stride=1, bias=True)
-        self.act1 = activation_from_name(norm_act)
-        self.fc2 = nn.Conv2d(reduction_channels, channels, kernel_size=1, stride=1, bias=True)
-
-    def forward(self, x):
-        x_se = self.pool(x)
-        x_se = self.fc1(x_se)
-        x_se = self.act1(x_se)
-        x_se = self.fc2(x_se)
-        return x * x_se.sigmoid()
-
-
 class BasicBlock(nn.Module):
     expansion = 1
 
@@ -146,7 +176,7 @@ def __init__(
         downsample=None,
         groups=1,
         base_width=64,
-        use_se=False,
+        attn_type=None,
         dilation=1,
         norm_layer=ABN,
         norm_act="relu",
@@ -163,7 +193,7 @@ def __init__(
         self.bn1 = norm_layer(planes, activation=norm_act)
         self.conv2 = conv3x3(planes, outplanes)
         self.bn2 = norm_layer(outplanes, activation="identity")
-        self.se_module = SEModule(outplanes, planes // 4) if use_se else None
+        self.se_module = get_attn(attn_type)(outplanes, planes // 4)
         self.final_act = activation_from_name(norm_act)
         self.downsample = downsample
         self.blurpool = BlurPool(channels=planes) if antialias else nn.Identity()
@@ -183,10 +213,7 @@ def forward(self, x):
             out = self.blurpool(out)
         out = self.conv2(out)
         # avoid 2 inplace ops by chaining into one long op. Needed for inplaceabn
-        if self.se_module is not None:
-            out = self.drop_connect(self.se_module(self.bn2(out))) + residual
-        else:
-            out = self.drop_connect(self.bn2(out)) + residual
+        out = self.drop_connect(self.se_module(self.bn2(out))) + residual
         return self.final_act(out)
 
 
@@ -201,7 +228,7 @@ def __init__(
         downsample=None,
         groups=1,
         base_width=64,
-        use_se=False,
+        attn_type=None,
         dilation=1,
         norm_layer=ABN,
         norm_act="relu",
@@ -220,7 +247,7 @@ def __init__(
         self.bn2 = norm_layer(width, activation=norm_act)
         self.conv3 = conv1x1(width, outplanes)
         self.bn3 = norm_layer(outplanes, activation="identity")
-        self.se_module = SEModule(outplanes, planes // 4) if use_se else None
+        self.se_module = get_attn(attn_type)(outplanes, planes // 4)
         self.final_act = activation_from_name(norm_act)
         self.downsample = downsample
         self.blurpool = BlurPool(channels=width) if antialias else nn.Identity()
@@ -244,10 +271,7 @@ def forward(self, x):
 
         out = self.conv3(out)
         # avoid 2 inplace ops by chaining into one long op
-        if self.se_module is not None:
-            out = self.drop_connect(self.se_module(self.bn3(out))) + residual
-        else:
-            out = self.drop_connect(self.bn3(out)) + residual
+        out = self.drop_connect(self.se_module(self.bn3(out))) + residual
         return self.final_act(out)
 
 # TResnet models use slightly modified versions of BasicBlock and Bottleneck
@@ -258,7 +282,7 @@ def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.final_act = nn.ReLU(inplace=True)
         self.bn1.activation_param = 1e-3  # needed for loading weights
-        if not kwargs.get("use_se"):
+        if not kwargs.get("attn_type") == "se":
             return
         planes = kwargs["planes"]
         self.se_module = SEModule(planes, max(planes // 4, 64))
@@ -269,7 +293,7 @@ def __init__(self, **kwargs):
         self.final_act = nn.ReLU(inplace=True)
         self.bn1.activation_param = 1e-3 # needed for loading weights
         self.bn2.activation_param = 1e-3
-        if not kwargs["use_se"]:
+        if not kwargs.get("attn_type") == "se":
             return
         planes = kwargs["planes"]
         reduce_planes = max(planes * self.expansion // 8, 64)
@@ -291,8 +315,7 @@ def forward(self, x):
         if self.antialias:
             out = self.blurpool(out)
 
-        if self.se_module is not None:
-            out = self.se_module(out)
+        out = self.se_module(out)
 
         out = self.conv3(out)
         # avoid 2 inplace ops by chaining into one long op

From 0df40e2ec881b346f7ce368cc2924c310b86c529 Mon Sep 17 00:00:00 2001
From: Emil Zakirov <bonlimezak@gmail.com>
Date: Fri, 15 May 2020 20:31:18 +0300
Subject: [PATCH 22/54] use  as criterion in benchmarking

---
 tests/benchmarking/README.md      |  2 ++
 tests/benchmarking/memory_test.py | 12 +++++++-----
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/tests/benchmarking/README.md b/tests/benchmarking/README.md
index b5fe0be..37fd0a0 100644
--- a/tests/benchmarking/README.md
+++ b/tests/benchmarking/README.md
@@ -54,6 +54,8 @@ Mean of 10 runs 10 iters each BS=64: 54.97+-0.01 msecs Forward. 185.83+-5.13 mse
 **Resnet50 Baseline: 25.56M params**  
 Mean of 10 runs 10 iters each BS=64: 59.65+-0.07 msecs Forward. 164.39+-2.58 msecs Backward. Max memory: 5935.15Mb  
 
+**Resnet50 AMP** 25.56M params
+Mean of 10 runs 10 iters each BS=256: 111.44+-0.03 msecs Forward. 357.80+-1.61 msecs Backward. Max memory: 11226.14Mb. 545.56 imgs/sec
 
 **Resnet34 Leaky ReLU 21.82M params**  
 Mean of 10 runs 10 iters each BS=64: 30.81+-0.18 msecs Forward. 103.95+-1.05 msecs Backward. Max memory: 2766.59Mb  
diff --git a/tests/benchmarking/memory_test.py b/tests/benchmarking/memory_test.py
index d2c3f52..08c83be 100644
--- a/tests/benchmarking/memory_test.py
+++ b/tests/benchmarking/memory_test.py
@@ -44,7 +44,7 @@ def run_once():
             if forward_only:
                 torch.cuda.synchronize()
                 return start.elapsed_time(f_end), start.elapsed_time(f_end)
-            loss = criterion(output, TARGET)
+            loss = output.mean()
             optimizer.zero_grad()
             loss.backward()
             optimizer.step()
@@ -137,8 +137,6 @@ def run_once():
     N_RUNS = 10
     RUN_ITERS = 10
     INP = torch.ones((BS, 3, 224, 224), requires_grad=not args.forward).cuda(0)
-    TARGET = torch.ones(BS).long().cuda(0)
-    criterion = torch.nn.CrossEntropyLoss().cuda(0)
     for name, model in models_dict.items():
         print(f"{name} {count_parameters(model) / 1e6:.2f}M params")
         model = model.cuda(0)
@@ -152,11 +150,15 @@ def run_once():
     # now test segmentation models
     BS = 16
     INP = torch.ones((BS, 3, 224, 224), requires_grad=True).cuda(0)
-    TARGET = torch.ones((BS, 1, 224, 224)).cuda(0)
-    criterion = pt.losses.JaccardLoss().cuda(0)
 
     for name, model in segm_models_dict.items():
         enc_params = count_parameters(model.encoder) / 1e6
         total_params = count_parameters(model) / 1e6
         print(f"{name}. Encoder {enc_params:.2f}M. Decoder {total_params - enc_params:.2f}M. Total {total_params:.2f}M params")
+        model = model.cuda(0)
+        if args.amp:
+            model = amp.initialize(model, verbosity=0, opt_level="O1")
+            INP = INP.half()
+        if args.forward:
+            model.eval()
         test_model(model, forward_only=args.forward)

From 3be207bb108c0ff51f8b6f9b3387f7c47e202c49 Mon Sep 17 00:00:00 2001
From: bonlime <bonlimezak@gmail.com>
Date: Sat, 16 May 2020 12:44:43 +0300
Subject: [PATCH 23/54] change `deep_stem` to `stem_type` (#64)

---
 pytorch_tools/models/resnet.py  | 46 ++++++++++++++++++++++-----------
 pytorch_tools/models/tresnet.py |  5 +---
 tests/models/test_models.py     |  7 ++++-
 3 files changed, 38 insertions(+), 20 deletions(-)

diff --git a/pytorch_tools/models/resnet.py b/pytorch_tools/models/resnet.py
index 88a562c..8743dea 100644
--- a/pytorch_tools/models/resnet.py
+++ b/pytorch_tools/models/resnet.py
@@ -19,6 +19,7 @@
 from pytorch_tools.modules.residual import conv1x1, conv3x3
 from pytorch_tools.modules.pooling import FastGlobalAvgPool2d
 from pytorch_tools.modules import bn_from_name
+from pytorch_tools.modules import SpaceToDepth
 from pytorch_tools.utils.misc import add_docs_for
 from pytorch_tools.utils.misc import DEFAULT_IMAGENET_SETTINGS
 from pytorch_tools.utils.misc import repeat_channels
@@ -58,8 +59,11 @@ class ResNet(nn.Module):
             Number of convolution groups for 3x3 conv in Bottleneck. Defaults to 1.
         base_width (int):
             Factor determining bottleneck channels. `planes * base_width / 64 * groups`. Defaults to 64.
-        deep_stem (bool):
-            Whether to replace the 7x7 conv1 with 3 3x3 convolution layers. Defaults to False.
+        stem_type (str):
+            Type on input stem. Supported options are: 
+            '' - default. One 7x7 conv with 64 channels
+            'deep' - three 3x3 conv with 32, 32, 64, channels
+            'space2depth' - Reshape followed by one convolution. Idea from TResNet paper 
         output_stride (List[8, 16, 32]): Applying dilation strategy to pretrained ResNet. Typically used in
             Semantic Segmentation. Defaults to 32.
             NOTE: Don't use this arg with `antialias` and `pretrained` together. it may produce weird results
@@ -93,7 +97,7 @@ def __init__(
         attn_type=None,
         groups=1,
         base_width=64,
-        deep_stem=False,
+        stem_type="",
         output_stride=32,
         norm_layer="abn",
         norm_act="relu",
@@ -118,18 +122,9 @@ def __init__(
         self.drop_connect_rate = drop_connect_rate
         super(ResNet, self).__init__()
 
-        if deep_stem:
-            self.conv1 = nn.Sequential(
-                conv3x3(in_channels, stem_width // 2, 2),
-                norm_layer(stem_width // 2, activation=norm_act),
-                conv3x3(stem_width // 2, stem_width // 2),
-                norm_layer(stem_width // 2, activation=norm_act),
-                conv3x3(stem_width // 2, stem_width),
-            )
-        else:
-            self.conv1 = nn.Conv2d(in_channels, stem_width, kernel_size=7, stride=2, padding=3, bias=False)
-        self.bn1 = norm_layer(stem_width, activation=norm_act)
-        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+        # move stem creation in separate function for simplicity
+        self._make_stem(stem_type, stem_width, in_channels, norm_layer, norm_act)
+
         if output_stride not in [8, 16, 32]:
             raise ValueError("Output stride should be in [8, 16, 32]")
         if output_stride == 8:
@@ -213,6 +208,27 @@ def _make_layer(
             )
         return nn.Sequential(*layers)
 
+    def _make_stem(self, stem_type, stem_width, in_channels, norm_layer, norm_act):
+        assert stem_type in {"", "deep", "space2depth"}, f"Stem type {stem_type} is not supported"
+        if stem_type == "space2depth":
+            # in the paper they use conv1x1 but in code conv3x3 (which seems better)
+            self.conv1 = nn.Sequential(SpaceToDepth(), conv3x3(in_channels * 16, stem_width))
+            self.bn1 = norm_layer(stem_width, activation=norm_act)
+            self.maxpool = nn.Identity() # not used but needed for code compatability
+        else:
+            if stem_type == "deep":
+                self.conv1 = nn.Sequential(
+                    conv3x3(in_channels, stem_width // 2, 2),
+                    norm_layer(stem_width // 2, activation=norm_act),
+                    conv3x3(stem_width // 2, stem_width // 2),
+                    norm_layer(stem_width // 2, activation=norm_act),
+                    conv3x3(stem_width // 2, stem_width),
+                )
+            else:
+                self.conv1 = nn.Conv2d(in_channels, stem_width, kernel_size=7, stride=2, padding=3, bias=False)
+            self.bn1 = norm_layer(stem_width, activation=norm_act)
+            self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+
     def _initialize_weights(self, init_bn0=False):
         for m in self.modules():
             if isinstance(m, nn.Conv2d):
diff --git a/pytorch_tools/models/tresnet.py b/pytorch_tools/models/tresnet.py
index 52849f7..022c9b0 100644
--- a/pytorch_tools/models/tresnet.py
+++ b/pytorch_tools/models/tresnet.py
@@ -83,10 +83,7 @@ def __init__(
         self.num_blocks = sum(layers)
         self.drop_connect_rate = drop_connect_rate
 
-        # in the paper they use conv1x1 but in code conv3x3 (which seems better)
-        self.conv1 = nn.Sequential(SpaceToDepth(), conv3x3(in_channels * 16, stem_width))
-        self.bn1 = norm_layer(stem_width, activation=norm_act)
-        self.maxpool = nn.Identity() # not used but needed for code compatability
+        self._make_stem("space2depth", stem_width, in_channels, norm_layer, norm_act)
 
         if output_stride not in [8, 16, 32]:
             raise ValueError("Output stride should be in [8, 16, 32]")
diff --git a/tests/models/test_models.py b/tests/models/test_models.py
index b251ba9..d5fb396 100644
--- a/tests/models/test_models.py
+++ b/tests/models/test_models.py
@@ -100,4 +100,9 @@ def test_drop_connect(arch):
 def test_num_parameters(name_num_params):
     name, num_params = name_num_params[0]
     m = models.__dict__[name]()
-    assert pt.utils.misc.count_parameters(m)[0] == num_params
\ No newline at end of file
+    assert pt.utils.misc.count_parameters(m)[0] == num_params
+
+@pytest.mark.parametrize('stem_type', ["", "deep", "space2depth"])
+def test_resnet_stem_type(stem_type):
+    m = models.resnet50(stem_type=stem_type)
+    _test_forward(m)
\ No newline at end of file

From a991342da841fb54d763eba4b0a8fc16c39d84b8 Mon Sep 17 00:00:00 2001
From: Emil Zakirov <bonlimezak@gmail.com>
Date: Tue, 19 May 2020 12:51:02 +0300
Subject: [PATCH 24/54] update doc for ModelEma Callback

---
 pytorch_tools/fit_wrapper/callbacks.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pytorch_tools/fit_wrapper/callbacks.py b/pytorch_tools/fit_wrapper/callbacks.py
index d38e3bd..e8d04fb 100644
--- a/pytorch_tools/fit_wrapper/callbacks.py
+++ b/pytorch_tools/fit_wrapper/callbacks.py
@@ -732,7 +732,7 @@ class ModelEma(Callback):
     NOTE: put this Callback AFTER Checkpoint saver! Otherwise you would validate EMA weights but save
     model weights
 
-    NOTE: Only need to be used in master process! otherwise it would take extra memory on all GPUs
+    NOTE: Need to be used in all process (not only master)! otherwise you would save not the best model bur some random
 
     NOTE: Pass model to ModelEma after cuda() and AMP but before SyncBN and DDP wrapper
 

From 7271b4a5a43cc7498cdbec1c33b00bc188303017 Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Wed, 20 May 2020 19:58:46 +0300
Subject: [PATCH 25/54] fix encoder_features for efficientnet

---
 pytorch_tools/models/efficientnet.py          | 15 +++++++--------
 pytorch_tools/segmentation_models/encoders.py | 16 ++++++++--------
 2 files changed, 15 insertions(+), 16 deletions(-)

diff --git a/pytorch_tools/models/efficientnet.py b/pytorch_tools/models/efficientnet.py
index 7e01a35..d9ab577 100644
--- a/pytorch_tools/models/efficientnet.py
+++ b/pytorch_tools/models/efficientnet.py
@@ -127,18 +127,19 @@ def __init__(
             self.blocks.append(nn.Sequential(*block))
 
         # Head
-        out_channels = block_arg["out_channels"]
-        num_features = make_divisible(1280 * width_multiplier)
-        self.conv_head = conv1x1(out_channels, num_features)
-        self.bn2 = norm_layer(num_features, activation=norm_act)
 
         if encoder:
             self.forward = self.encoder_features
         else:
+            out_channels = block_arg["out_channels"]
+            num_features = make_divisible(1280 * width_multiplier)
+            self.conv_head = conv1x1(out_channels, num_features)
+            self.bn2 = norm_layer(num_features, activation=norm_act)
             self.global_pool = nn.AdaptiveAvgPool2d(1)
             self.dropout = nn.Dropout(drop_rate, inplace=True)
             self.classifier = nn.Linear(num_features, num_classes)
 
+        # TODO: change to init from official repo. It may be the source of problem for training from scratch
         initialize(self)
 
     def encoder_features(self, x):
@@ -148,11 +149,9 @@ def encoder_features(self, x):
         x1 = self.blocks[1](x0)
         x2 = self.blocks[2](x1)
         x3 = self.blocks[3](x2)
-        x4 = self.blocks[4](x3)
-        x4 = self.blocks[5](x4)
+        x3 = self.blocks[4](x3)
+        x4 = self.blocks[5](x3)
         x4 = self.blocks[6](x4)
-        x4 = self.conv_head(x4)
-        x4 = self.bn2(x4)
         return [x4, x3, x2, x1, x0]
 
     def features(self, x):
diff --git a/pytorch_tools/segmentation_models/encoders.py b/pytorch_tools/segmentation_models/encoders.py
index 4f11acc..088a48e 100644
--- a/pytorch_tools/segmentation_models/encoders.py
+++ b/pytorch_tools/segmentation_models/encoders.py
@@ -23,14 +23,14 @@
     "densenet201": (1920, 1792, 512, 256, 64),
     #'densenet161': (2208, 2112, 768, 384, 96),
     
-    "efficientnet_b0": (1280, 80, 40, 24, 16),
-    "efficientnet_b1": (1280, 80, 40, 24, 16),
-    "efficientnet_b2": (1408, 88, 48, 24, 16),
-    "efficientnet_b3": (1536, 96, 48, 32, 24),
-    "efficientnet_b4": (1792, 112, 56, 32, 24),
-    "efficientnet_b5": (2048, 128, 64, 40, 24),
-    "efficientnet_b6": (2304, 144, 72, 40, 32),
-    "efficientnet_b7": (2560, 160, 80, 48, 32),
+    "efficientnet_b0": (320, 112, 40, 24, 16),
+    "efficientnet_b1": (320, 112, 40, 24, 16),
+    "efficientnet_b2": (352, 120, 48, 24, 16),
+    "efficientnet_b3": (384, 136, 48, 32, 24),
+    "efficientnet_b4": (448, 160, 56, 32, 24),
+    "efficientnet_b5": (512, 176, 64, 40, 24),
+    "efficientnet_b6": (576, 200, 72, 40, 32),
+    "efficientnet_b7": (640, 224, 80, 48, 32),
 
     # this models return feature maps at OS= 32, 16, 8, 4, 4
     # they CAN'T be used as encoders in Unet and Linknet

From 72a5af7ebbbabae0020a30a8a8d3137c0eb91064 Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Wed, 20 May 2020 20:07:34 +0300
Subject: [PATCH 26/54] add TF same Conv and MaxPool

---
 pytorch_tools/modules/residual.py             |  6 +-
 pytorch_tools/modules/tf_same_ops.py          | 68 +++++++++++++++++++
 .../modules/weight_standartization.py         |  4 --
 3 files changed, 71 insertions(+), 7 deletions(-)
 create mode 100644 pytorch_tools/modules/tf_same_ops.py

diff --git a/pytorch_tools/modules/residual.py b/pytorch_tools/modules/residual.py
index a614ebb..2ea7816 100644
--- a/pytorch_tools/modules/residual.py
+++ b/pytorch_tools/modules/residual.py
@@ -82,11 +82,11 @@ def get_attn(attn_type):
 class DepthwiseSeparableConv(nn.Sequential):
     """Depthwise separable conv with BN after depthwise & pointwise."""
 
-    def __init__(self, in_channels, out_channels, stride=1, dilation=1, norm_layer=ABN, norm_act="relu"):
+    def __init__(self, in_channels, out_channels, stride=1, dilation=1, norm_layer=ABN, norm_act="relu", use_norm=True):
         modules = [
             conv3x3(in_channels, in_channels, stride=stride, groups=in_channels, dilation=dilation),
-            conv1x1(in_channels, out_channels),
-            norm_layer(out_channels, activation=norm_act),
+            conv1x1(in_channels, out_channels, bias=True), # in efficient det they for some reason add bias
+            norm_layer(out_channels, activation=norm_act) if use_norm else nn.Identity(),
         ]
         super().__init__(*modules)
 
diff --git a/pytorch_tools/modules/tf_same_ops.py b/pytorch_tools/modules/tf_same_ops.py
new file mode 100644
index 0000000..6a5a910
--- /dev/null
+++ b/pytorch_tools/modules/tf_same_ops.py
@@ -0,0 +1,68 @@
+"""Implementations of Conv2d and MaxPool which match Tensorflow `same` padding"""
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class Conv2dSamePadding(nn.Conv2d):
+    """
+    Assymetric padding matching TensorFlow `same`
+    """ 
+    def forward(self, x):
+        h, w = x.shape[-2:]
+        pad_w = (math.ceil(w / self.stride[1]) - 1) * self.stride[1] - w + self.kernel_size[1]
+        pad_h = (math.ceil(h / self.stride[0]) - 1) * self.stride[0] - h + self.kernel_size[0]
+        x = F.pad(x, [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2])
+        return super().forward(x)
+
+    
+class MaxPool2dSamePadding(nn.MaxPool2d):
+    """
+    Assymetric padding matching TensorFlow `same`
+    """ 
+    def forward(self, x):
+        h, w = x.shape[-2:]
+        pad_w = (math.ceil(w / self.stride) - 1) * self.stride - w + self.kernel_size
+        pad_h = (math.ceil(h / self.stride) - 1) * self.stride - h + self.kernel_size
+        x = F.pad(x, [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2])
+        return super().forward(x)
+
+    
+def conv_to_same_conv(module):
+    module_output = module
+    # skip 1x1 convs 
+    if isinstance(module, nn.Conv2d) and module.kernel_size[0] != 1:
+        module_output = Conv2dSamePadding(
+            in_channels=module.in_channels,
+            out_channels=module.out_channels,
+            kernel_size=module.kernel_size,
+            stride=module.stride,
+            padding=0, # explicitly set to 0
+            dilation=module.dilation,
+            groups=module.groups, 
+            bias=module.bias is not None,
+        )
+        with torch.no_grad():
+            module_output.weight.copy_(module.weight)
+            module_output.weight.requires_grad = module.weight.requires_grad
+            if module.bias is not None:
+                module_output.bias.copy_(module.bias)
+                module_output.bias.requires_grad = module.bias.requires_grad
+
+    for name, child in module.named_children():
+        module_output.add_module(name, conv_to_same_conv(child))
+    del module
+    return module_output
+
+def maxpool_to_same_maxpool(module):
+    module_output = module
+    if isinstance(module, nn.MaxPool2d):
+        module_output = MaxPool2dSamePadding(
+            kernel_size=module.kernel_size,
+            stride=module.stride,
+            padding=0, # explicitly set to 0
+        )
+    for name, child in module.named_children():
+        module_output.add_module(name, maxpool_to_same_maxpool(child))
+    del module
+    return module_output
\ No newline at end of file
diff --git a/pytorch_tools/modules/weight_standartization.py b/pytorch_tools/modules/weight_standartization.py
index a250524..ebe614b 100644
--- a/pytorch_tools/modules/weight_standartization.py
+++ b/pytorch_tools/modules/weight_standartization.py
@@ -5,10 +5,6 @@
 # implements idea from `Weight Standardization` paper https://arxiv.org/abs/1903.10520
 # eps is inside sqrt to avoid overflow Idea from https://arxiv.org/abs/1911.05920    
 class WS_Conv2d(nn.Conv2d):
-    def __init__(self, in_channels, out_channels, kernel_size, stride=1,
-                 padding=0, dilation=1, groups=1, bias=True):
-        super().__init__(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias)
-        
     def forward(self, x):
         weight = self.weight
         weight = weight.sub(weight.mean(dim=(1, 2, 3), keepdim=True))

From f46b3416f8a885422705c4558d4e4047c179e49c Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Wed, 20 May 2020 20:11:26 +0300
Subject: [PATCH 27/54] add working EffDet

---
 pytorch_tools/detection_models/__init__.py    |   9 +-
 .../detection_models/efficientdet.py          | 149 +++++++++++++
 pytorch_tools/modules/bifpn.py                | 211 ++++++++++--------
 3 files changed, 273 insertions(+), 96 deletions(-)
 create mode 100644 pytorch_tools/detection_models/efficientdet.py

diff --git a/pytorch_tools/detection_models/__init__.py b/pytorch_tools/detection_models/__init__.py
index 7c7fc59..8f2dd8e 100644
--- a/pytorch_tools/detection_models/__init__.py
+++ b/pytorch_tools/detection_models/__init__.py
@@ -1 +1,8 @@
-from .retinanet import RetinaNet
\ No newline at end of file
+from .retinanet import RetinaNet
+from .efficientdet import efficientdet_b0
+from .efficientdet import efficientdet_b1
+from .efficientdet import efficientdet_b2
+from .efficientdet import efficientdet_b3
+from .efficientdet import efficientdet_b4
+from .efficientdet import efficientdet_b5
+from .efficientdet import efficientdet_b6
\ No newline at end of file
diff --git a/pytorch_tools/detection_models/efficientdet.py b/pytorch_tools/detection_models/efficientdet.py
new file mode 100644
index 0000000..dbd617b
--- /dev/null
+++ b/pytorch_tools/detection_models/efficientdet.py
@@ -0,0 +1,149 @@
+import torch
+import torch.nn as nn
+from pytorch_tools.modules import ABN
+from pytorch_tools.modules.bifpn import BiFPN
+from pytorch_tools.modules import bn_from_name
+from pytorch_tools.modules.residual import conv1x1
+from pytorch_tools.modules.residual import conv3x3
+from pytorch_tools.modules.residual import DepthwiseSeparableConv
+from pytorch_tools.modules.tf_same_ops import conv_to_same_conv
+from pytorch_tools.modules.tf_same_ops import maxpool_to_same_maxpool
+from pytorch_tools.segmentation_models.encoders import get_encoder
+
+def patch_bn(module):
+    """TF ported weights use slightly different eps in BN. Need to adjust for better performance"""
+    if isinstance(module, ABN):
+        module.eps = 1e-3
+        module.momentum = 1e-2
+    for m in module.children():
+        patch_bn(m)
+
+class EfficientDet(nn.Module):
+    def __init__(
+        self, 
+        encoder_name="efficientnet_b0",
+        encoder_weights="imagenet",
+        pyramid_channels=64,
+        num_fpn_layers=3,
+        num_head_repeats=3,
+        num_classes=90,
+        drop_connect_rate=0,
+        encoder_norm_layer="abn", # TODO: set to frozenabn when ready
+        encoder_norm_act="swish",
+        decoder_norm_layer="abn",
+        decoder_norm_act="swish",
+        match_tf_same_padding=False,
+        ):
+        super().__init__()
+        self.encoder = get_encoder(
+            encoder_name,
+            norm_layer=encoder_norm_layer,
+            norm_act=encoder_norm_act,
+            encoder_weights=encoder_weights,
+        )
+        norm_layer = bn_from_name(decoder_norm_layer)
+        bn_args = dict(norm_layer=norm_layer, norm_act=decoder_norm_act)
+        self.pyramid6 = nn.Sequential(
+            conv1x1(self.encoder.out_shapes[0], pyramid_channels, bias=True),
+            norm_layer(pyramid_channels, activation="identity"),
+            nn.MaxPool2d(3, stride=2, padding=1)
+        )
+        self.pyramid7 = nn.MaxPool2d(3, stride=2, padding=1) # in EffDet it's a simple maxpool
+
+        self.bifpn = BiFPN(
+            self.encoder.out_shapes[:-2],
+            pyramid_channels=pyramid_channels,
+            num_layers=num_fpn_layers,
+            **bn_args,
+        )
+
+        def make_head(out_size):
+            layers = []
+            for _ in range(num_head_repeats):
+                # TODO: add drop connect
+                layers += [DepthwiseSeparableConv(pyramid_channels, pyramid_channels, use_norm=False)]
+            layers += [DepthwiseSeparableConv(pyramid_channels, out_size, use_norm=False)]
+            return nn.ModuleList(layers)
+        
+        def make_head_norm():
+            return nn.ModuleList([
+                nn.ModuleList(
+                    [
+                        norm_layer(pyramid_channels, activation=decoder_norm_act)
+                        for _ in range(num_head_repeats)
+                    ] + [nn.Identity()] # no bn after last depthwise conv
+                )
+                for _ in range(5)
+            ])
+        anchors_per_location = 9 # TODO: maybe allow to pass this arg?
+        self.cls_head_convs = make_head(num_classes * anchors_per_location)
+        self.cls_head_norms = make_head_norm()
+        self.box_head_convs = make_head(4 * anchors_per_location)
+        self.box_head_norms = make_head_norm()
+        self.num_classes = num_classes
+
+        patch_bn(self)
+        if match_tf_same_padding:
+            conv_to_same_conv(self)
+            maxpool_to_same_maxpool(self)
+            
+
+    def forward(self, x):
+        # don't use p2 and p1
+        p5, p4, p3, _, _ = self.encoder(x)
+        # coarser FPN levels
+        p6 = self.pyramid6(p5)
+        p7 = self.pyramid7(p6)
+        features = [p7, p6, p5, p4, p3]
+        # enhance features
+        features = self.bifpn(features)
+        # want features from lowest OS to highest to align with `generate_anchors_boxes` function 
+        features = list(reversed(features))
+        class_outputs = []
+        box_outputs = []
+        for feat, (cls_bns, box_bns) in zip(features, zip(self.cls_head_norms, self.box_head_norms)):
+            cls_feat, box_feat = feat, feat
+            for cls_conv, cls_bn in zip(self.cls_head_convs, cls_bns):
+                cls_feat = cls_bn(cls_conv(cls_feat))
+            for box_conv, box_bn in zip(self.box_head_convs, box_bns):
+                box_feat = box_bn(box_conv(box_feat))
+
+            box_feat = box_feat.permute(0, 2, 3, 1)
+            box_outputs.append(box_feat.contiguous().view(box_feat.shape[0], -1, 4))
+
+            cls_feat = cls_feat.permute(0, 2, 3, 1)
+            class_outputs.append(cls_feat.contiguous().view(cls_feat.shape[0], -1, self.num_classes))
+
+            # TODO: return back to simplier transpose operations
+            # class_outputs.append(cls_feat.transpose(1, 3).contiguous().view(x.shape[0], -1, self.num_classes))
+            # box_outputs.append(box_feat.transpose(1, 3).contiguous().view(x.shape[0], -1, 4))
+
+        class_outputs = torch.cat(class_outputs , 1)
+        box_outputs = torch.cat(box_outputs, 1)
+        return class_outputs, box_outputs
+
+
+
+def efficientdet_b0(**kwargs):
+    return EfficientDet(**kwargs)
+
+def efficientdet_b1(**kwargs):
+    return EfficientDet(
+        encoder_name="efficientnet_b1", pyramid_channels=88, num_fpn_layers=4, num_head_repeats=3, **kwargs)
+
+def efficientdet_b2(**kwargs):
+    return EfficientDet(encoder_name="efficientnet_b2", pyramid_channels=112, num_fpn_layers=5, num_head_repeats=3, **kwargs)
+
+def efficientdet_b3(**kwargs):
+    return EfficientDet(encoder_name="efficientnet_b3", pyramid_channels=160, num_fpn_layers=6, num_head_repeats=4, **kwargs)
+
+def efficientdet_b4(**kwargs):
+    return EfficientDet(encoder_name="efficientnet_b4", pyramid_channels=224, num_fpn_layers=7, num_head_repeats=4, **kwargs)
+    
+def efficientdet_b5(**kwargs):
+    return EfficientDet(encoder_name="efficientnet_b5", pyramid_channels=288, num_fpn_layers=7, num_head_repeats=4, **kwargs)
+
+def efficientdet_b6(*args, **kwargs):
+    return EfficientDet(encoder_name="efficientnet_b6", pyramid_channels=384, num_fpn_layers=8, num_head_repeats=5, **kwargs)
+
+# No B7 because it's the same model as B6 but with larger input
\ No newline at end of file
diff --git a/pytorch_tools/modules/bifpn.py b/pytorch_tools/modules/bifpn.py
index 2f603c2..406df57 100644
--- a/pytorch_tools/modules/bifpn.py
+++ b/pytorch_tools/modules/bifpn.py
@@ -2,17 +2,21 @@
 import torch.nn as nn
 import torch.nn.functional as F
 
+from .activations import activation_from_name
 from .residual import DepthwiseSeparableConv
+from .residual import conv1x1
+from . import ABN
 
 class FastNormalizedFusion(nn.Module):
     """Combines 2 or 3 feature maps into one with weights.
     Args:
         input_num (int): 2 for intermediate features, 3 for output features
     """
-    def __init__(self, in_nodes):
+    def __init__(self, in_nodes, activation="relu"):
         super().__init__()
         self.weights = nn.Parameter(torch.ones(in_nodes, dtype=torch.float32))
-        self.register_buffer("eps", torch.tensor(0.0001))
+        self.eps = 1e-4
+        self.act = activation_from_name(activation)
 
     def forward(self, *features):
         # Assure that weights are positive (see paper)
@@ -20,103 +24,138 @@ def forward(self, *features):
         # Normalize weights
         weights /= weights.sum() + self.eps
         fused_features = sum([p * w for p, w in zip(features, weights)])
-        return fused_features
-
+        return self.act(fused_features)
 
+# need to create weights to allow loading anyway. So inherit from FastNormalizedFusion for simplicity
+class SumFusion(FastNormalizedFusion):
+    def forward(self, *features):
+        return self.act(sum(features))
 
 
-# close to one in the paper
 class BiFPNLayer(nn.Module):
     r"""Builds one layer of Bi-directional Feature Pyramid Network
     Args:
         channels (int): Number of channels in each feature map after BiFPN. Defaults to 64.
-        downsample_by_stride (bool): If True, use convolution layer with stride=2 instead of F.interpolate
-        upsample_mode (str): how to upsample low resolution features during top_down pathway. 
-            See F.interpolate mode for details.
-
+        
     Input:
-        features (List): 5 feature maps from encoder with resolution from 1/32 to 1/2
+        features (List): 5 feature maps from encoder with resolution from 1/128 to 1/8
 
     Returns:
         p_out: features processed by 1 layer of BiFPN
     """
 
-    def __init__(self, channels=64, output_stride=32, upsample_mode="nearest", **bn_args):
-        super(BiFPNLayer, self).__init__()
-
-        self.up = nn.Upsample(scale_factor=2, mode=upsample_mode)
-        self.first_up = self.up if output_stride == 32 else nn.Identity()
-        last_stride = 2 if output_stride == 32 else 1
-        self.down_p2 = DepthwiseSeparableConv(channels, channels, stride=2, **bn_args)
-        self.down_p3 = DepthwiseSeparableConv(channels, channels, stride=2, **bn_args)
-        self.down_p4 = DepthwiseSeparableConv(channels, channels, stride=last_stride, **bn_args)
-
-        ## TODO (jamil) 11.02.2020 Rewrite this using list comprehensions
-        self.fuse_p4_td = FastNormalizedFusion(in_nodes=2)
-        self.fuse_p3_td = FastNormalizedFusion(in_nodes=2)
-        self.fuse_p2_td = FastNormalizedFusion(in_nodes=2)
-        self.fuse_p1_td = FastNormalizedFusion(in_nodes=2)
+    def __init__(self, channels=64, norm_layer=ABN, norm_act="relu"):
+        super().__init__()
 
-        # Top-down pathway, no block for P1 layer
-        self.p4_td = DepthwiseSeparableConv(channels, channels, **bn_args)
-        self.p3_td = DepthwiseSeparableConv(channels, channels, **bn_args)
-        self.p2_td = DepthwiseSeparableConv(channels, channels, **bn_args)
+        self.up = nn.Upsample(scale_factor=2, mode="nearest")
+        self.down = nn.MaxPool2d(3, stride=2, padding=1) #  padding=1 TODO: change back
+        
+        # disable attention for large models. This is very dirty way to check that it's B6 & B7. But i don't care
+        Fusion = FastNormalizedFusion if channels < 288 else SumFusion
+
+        # There is no activation in SeparableConvs, instead activation is in fusion layer
+        self.fuse_p6_up = Fusion(in_nodes=2, activation=norm_act)
+        self.fuse_p5_up = Fusion(in_nodes=2, activation=norm_act)
+        self.fuse_p4_up = Fusion(in_nodes=2, activation=norm_act)
+
+        self.fuse_p3_out = Fusion(in_nodes=2, activation=norm_act)
+        self.fuse_p4_out = Fusion(in_nodes=3, activation=norm_act)
+        self.fuse_p5_out = Fusion(in_nodes=3, activation=norm_act)
+        self.fuse_p6_out = Fusion(in_nodes=3, activation=norm_act)
+        self.fuse_p7_out = Fusion(in_nodes=2, activation=norm_act)
+
+        bn_args = dict(norm_layer=norm_layer, norm_act="identity")
+        # Top-down pathway, no block for P7 layer
+        self.p6_up = DepthwiseSeparableConv(channels, channels, **bn_args)
+        self.p5_up = DepthwiseSeparableConv(channels, channels, **bn_args)
+        self.p4_up = DepthwiseSeparableConv(channels, channels, **bn_args)
 
         # Bottom-up pathway
-        self.fuse_p2_out = FastNormalizedFusion(in_nodes=3)
-        self.fuse_p3_out = FastNormalizedFusion(in_nodes=3)
-        self.fuse_p4_out = FastNormalizedFusion(in_nodes=3)
-        self.fuse_p5_out = FastNormalizedFusion(in_nodes=2)
-
-        self.p5_out = DepthwiseSeparableConv(channels, channels, **bn_args)
-        self.p4_out = DepthwiseSeparableConv(channels, channels, **bn_args)
         self.p3_out = DepthwiseSeparableConv(channels, channels, **bn_args)
-        
+        self.p4_out = DepthwiseSeparableConv(channels, channels, **bn_args)
+        self.p5_out = DepthwiseSeparableConv(channels, channels, **bn_args)
+        self.p6_out = DepthwiseSeparableConv(channels, channels, **bn_args)
+        self.p7_out = DepthwiseSeparableConv(channels, channels, **bn_args)    
     
     def forward(self, features):
-        p5_inp, p4_inp, p3_inp, p2_inp = features
+
+        # p7, p6, p5, p4, p3
+        p7_in, p6_in, p5_in, p4_in, p3_in = features
         
-        # Top-down pathway
-        p4_td = self.p4_td(self.fuse_p4_td(p4_inp, self.first_up(p5_inp)))
-        p3_td = self.p3_td(self.fuse_p3_td(p3_inp, self.up(p4_td)))
-        p2_out = self.p2_td(self.fuse_p2_td(p2_inp, self.up(p3_td)))
+        # Top-down pathway (from low res to high res)
+        p6_up = self.p6_up(self.fuse_p6_up(p6_in, self.up(p7_in)))
+        p5_up = self.p5_up(self.fuse_p5_up(p5_in, self.up(p6_up)))
+        p4_up = self.p4_up(self.fuse_p4_up(p4_in, self.up(p5_up)))
+        p3_out = self.p3_out(self.fuse_p3_out(p3_in, self.up(p4_up)))
+
+        # Bottom-Up Pathway (from high res to low res)
+        p4_out = self.p4_out(self.fuse_p4_out(p4_in, p4_up, self.down(p3_out)))
+        p5_out = self.p5_out(self.fuse_p5_out(p5_in, p5_up, self.down(p4_out)))
+        p6_out = self.p6_out(self.fuse_p6_out(p6_in, p6_up, self.down(p5_out)))
+        p7_out = self.p7_out(self.fuse_p7_out(p7_in, self.down(p6_out)))
+
+        return p7_out, p6_out, p5_out, p4_out, p3_out
+
+# additionally downsamples the input
+class FirstBiFPNLayer(BiFPNLayer):
+    def __init__(self, encoder_channels, channels=64, norm_layer=ABN, norm_act="relu"):
+        super().__init__(channels=channels, norm_layer=norm_layer, norm_act=norm_act)
+
+        # TODO: later remove bias from downsample 
+        self.p5_downsample_1 = nn.Sequential(
+            conv1x1(encoder_channels[0], channels, bias=True), 
+            norm_layer(channels, activation="identity")
+        )
+        self.p4_downsample_1 = nn.Sequential(
+            conv1x1(encoder_channels[1], channels, bias=True),
+            norm_layer(channels, activation="identity")
+        )
+        self.p3_downsample_1 = nn.Sequential(
+            conv1x1(encoder_channels[2], channels, bias=True),
+            norm_layer(channels, activation="identity")
+        )
+
+        # Devil is in the details. In original repo they use 2 different downsamples from encoder channels
+        # it makes sense to preseve more information, but most of implementations in the internet 
+        # use output of the first downsample
+        self.p4_downsample_2 = nn.Sequential(
+            conv1x1(encoder_channels[1], channels, bias=True),
+            norm_layer(channels, activation="identity")
+        )
+        self.p5_downsample_2 = nn.Sequential(
+            conv1x1(encoder_channels[0], channels, bias=True), 
+            norm_layer(channels, activation="identity")
+        )
+        # only one downsample for p3 
 
-        # Calculate Bottom-Up Pathway
-        p3_out = self.p3_out(self.fuse_p3_out(p3_inp, p3_td, self.down_p2(p2_out)))
-        p4_out = self.p4_out(self.fuse_p4_out(p4_inp, p4_td, self.down_p3(p3_out)))
-        p5_out = self.p5_out(self.fuse_p5_out(p5_inp, self.down_p4(p4_out)))
 
-        return p5_out, p4_out, p3_out, p2_out
+    def forward(self, features):
 
-# very simplified
-class SimpleBiFPNLayer(nn.Module):
-    def __init__(self, channels=64, **bn_args):
-        super(SimpleBiFPNLayer, self).__init__()
+        # p7, p6, p5, p4, p3
+        p7_in, p6_in, p5_in, p4_in, p3_in = features
 
-        self.up = nn.Upsample(scale_factor=2, mode="nearest")
-        self.down_p2 = DepthwiseSeparableConv(channels, channels, stride=2)
-        self.down_p3 = DepthwiseSeparableConv(channels, channels, stride=2)
-        self.down_p4 = DepthwiseSeparableConv(channels, channels, stride=2)
+        # downsample input's convs
+        p5_in_down1 = self.p5_downsample_1(p5_in)
+        p5_in_down2 = self.p5_downsample_2(p5_in)
+        p4_in_down1 = self.p4_downsample_1(p4_in)
+        p4_in_down2 = self.p4_downsample_2(p4_in)
+        p3_in_down1 = self.p3_downsample_1(p3_in)
 
-        self.fuse = sum
+        # Top-down pathway (from low res to high res)
+        p6_up = self.p6_up(self.fuse_p6_up(p6_in, self.up(p7_in)))
+        p5_up = self.p5_up(self.fuse_p5_up(p5_in_down1, self.up(p6_up)))
+        p4_up = self.p4_up(self.fuse_p4_up(p4_in_down1, self.up(p5_up)))
+        p3_out = self.p3_out(self.fuse_p3_out(p3_in_down1, self.up(p4_up)))
 
-    def forward(self, features):
-        p5_inp, p4_inp, p3_inp, p2_inp = features
-        
-        # Top-down pathway
-        p4_td = self.fuse(p4_inp, self.up(p5_inp))
-        p3_td = self.fuse(p3_inp, self.up(p4_td))
-        p2_out = self.fuse(p2_inp, self.up(p3_td))
+        # Bottom-Up Pathway (from high res to low res)
+        p4_out = self.p4_out(self.fuse_p4_out(p4_in_down2, p4_up, self.down(p3_out)))
+        p5_out = self.p5_out(self.fuse_p5_out(p5_in_down2, p5_up, self.down(p4_out)))
+        p6_out = self.p6_out(self.fuse_p6_out(p6_in, p6_up, self.down(p5_out)))
+        p7_out = self.p7_out(self.fuse_p7_out(p7_in, self.down(p6_out)))
 
-        # Calculate Bottom-Up Pathway
-        p3_out = self.fuse(p3_inp, p3_td, self.down_p2(p2_out))
-        p4_out = self.fuse(p4_inp, p4_td, self.down_p3(p3_out))
-        p5_out = self.fuse(p5_inp, self.down_p4(p4_out))
+        return p7_out, p6_out, p5_out, p4_out, p3_out
 
-        return p5_out, p4_out, p3_out, p2_out
-
-
-class BiFPN(nn.Module):
+class BiFPN(nn.Sequential):
     """
     Implementation of Bi-directional Feature Pyramid Network
 
@@ -131,28 +170,10 @@ class BiFPN(nn.Module):
     https://arxiv.org/pdf/1911.09070.pdf
     """
 
-    def __init__(
-        self,
-        encoder_channels,
-        pyramid_channels=64,
-        num_layers=1,
-        output_stride=32,
-        **bn_args,
-    ):
-        super(BiFPN, self).__init__()
-
-        self.input_convs = nn.ModuleList([nn.Conv2d(in_ch, pyramid_channels, 1) for in_ch in encoder_channels])
-
-        bifpns = []
-        for _ in range(num_layers):
-            bifpns.append(BiFPNLayer(pyramid_channels, output_stride, **bn_args))
-        self.bifpn = nn.Sequential(*bifpns)
-    
-    def forward(self, features):
-
-        # Preprocces raw encoder features 
-        p5, p4, p3, p2 = [inp_conv(feature) for inp_conv, feature in zip(self.input_convs, features)]
-
+    def __init__(self, encoder_channels, pyramid_channels=64, num_layers=1, **bn_args):  
+        # First layer preprocesses raw encoder features 
+        bifpns = [FirstBiFPNLayer(encoder_channels, pyramid_channels, **bn_args)]
         # Apply BiFPN block `num_layers` times
-        p5_out, p4_out, p3_out, p2_out = self.bifpn([p5, p4, p3, p2])
-        return p5_out, p4_out, p3_out, p2_out
+        for _ in range(num_layers - 1):
+            bifpns.append(BiFPNLayer(pyramid_channels, **bn_args))
+        super().__init__(*bifpns)
\ No newline at end of file

From d3500e6fea1b9a4f535053d5c33c207af62d97da Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Wed, 20 May 2020 20:12:35 +0300
Subject: [PATCH 28/54] minor

---
 README.md                         |  2 +-
 tests/benchmarking/memory_test.py | 16 +++++++++++-----
 2 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index c29c172..cdfa53b 100644
--- a/README.md
+++ b/README.md
@@ -12,7 +12,7 @@ Tool box for PyTorch for fast prototyping.
 * [TTA wrapper](./pytorch_tools/tta_wrapper/) - wrapper for easy test-time augmentation
 
 # Installation
-Requeres GPU drivers and CUDA already installed.
+Requires GPU drivers and CUDA already installed.
 
 `pip install -v --no-cache-dir --global-option="--cpp_ext" --global-option="--cuda_ext" git+https://github.com/NVIDIA/apex.git`  
 `pip install git+https://github.com/bonlime/pytorch-tools.git@master`
diff --git a/tests/benchmarking/memory_test.py b/tests/benchmarking/memory_test.py
index 08c83be..c355f3f 100644
--- a/tests/benchmarking/memory_test.py
+++ b/tests/benchmarking/memory_test.py
@@ -40,6 +40,8 @@ def test_model(model, forward_only=False):
         def run_once():
             start.record()
             output = model(INP)
+            if isinstance(output, tuple) and len(output) > 1:
+                output = output[0]
             f_end.record()
             if forward_only:
                 torch.cuda.synchronize()
@@ -70,10 +72,11 @@ def run_once():
         f_times = np.array(f_times)
         fb_times = np.array(fb_times)
     print(
-        "Mean of {} runs {} iters each BS={}:\n\t {:.2f}+-{:.2f} msecs Forward. {:.2f}+-{:.2f} msecs Backward. Max memory: {:.2f}Mb. {:.2f} imgs/sec".format(
+        "Mean of {} runs {} iters each BS={}, SZ={}:\n\t {:.2f}+-{:.2f} msecs Forward. {:.2f}+-{:.2f} msecs Backward. Max memory: {:.2f}Mb. {:.2f} imgs/sec".format(
             N_RUNS,
             RUN_ITERS,
             BS,
+            SZ,
             f_times.mean(),
             f_times.std(),
             (fb_times - f_times).mean(),
@@ -95,7 +98,10 @@ def run_once():
         "--amp", action="store_true", help="Measure speed using apex mixed precision"
     )
     parser.add_argument(
-        "--bs", default=64, type=int, help="BS for classification",
+        "--bs", default=64, type=int, help="BS for benchmarking",
+    )
+    parser.add_argument(
+        "--sz", default=224, type=int, help="Size of images for benchmarking",
     )
     args = parser.parse_args()
     # all models are first init to cpu memory to find errors earlier
@@ -134,9 +140,10 @@ def run_once():
 
     print("Initialized models")
     BS = args.bs
+    SZ = args.sz
     N_RUNS = 10
     RUN_ITERS = 10
-    INP = torch.ones((BS, 3, 224, 224), requires_grad=not args.forward).cuda(0)
+    INP = torch.ones((BS, 3, SZ, SZ), requires_grad=not args.forward).cuda(0)
     for name, model in models_dict.items():
         print(f"{name} {count_parameters(model) / 1e6:.2f}M params")
         model = model.cuda(0)
@@ -148,8 +155,7 @@ def run_once():
         test_model(model, forward_only=args.forward)
 
     # now test segmentation models
-    BS = 16
-    INP = torch.ones((BS, 3, 224, 224), requires_grad=True).cuda(0)
+    INP = torch.ones((BS, 3, SZ, SZ), requires_grad=True).cuda(0)
 
     for name, model in segm_models_dict.items():
         enc_params = count_parameters(model.encoder) / 1e6

From ae744fc4e34209571134da61f34e7725c09fc44a Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Thu, 21 May 2020 16:10:17 +0300
Subject: [PATCH 29/54] shorter weight standardization

---
 pytorch_tools/modules/weight_standartization.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/pytorch_tools/modules/weight_standartization.py b/pytorch_tools/modules/weight_standartization.py
index ebe614b..63d0b5d 100644
--- a/pytorch_tools/modules/weight_standartization.py
+++ b/pytorch_tools/modules/weight_standartization.py
@@ -5,11 +5,11 @@
 # implements idea from `Weight Standardization` paper https://arxiv.org/abs/1903.10520
 # eps is inside sqrt to avoid overflow Idea from https://arxiv.org/abs/1911.05920    
 class WS_Conv2d(nn.Conv2d):
+
     def forward(self, x):
         weight = self.weight
-        weight = weight.sub(weight.mean(dim=(1, 2, 3), keepdim=True))
-        std = weight.var(dim=(1, 2, 3), keepdim=True).add_(1e-7).sqrt_()
-        weight = weight.div(std.expand_as(weight))
+        var, mean = torch.var_mean(weight, dim=[1, 2, 3], keepdim=True, unbiased=False)
+        weight = (weight - mean) / torch.sqrt(var + 1e-7)
         return F.conv2d(x, weight, self.bias, self.stride, self.padding, self.dilation, self.groups)
 
 # code from SyncBatchNorm in pytorch

From ed3ab31431b6822c64bfa336b7dbd914391f63cc Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Thu, 21 May 2020 16:10:53 +0300
Subject: [PATCH 30/54] add new test imgs

---
 tests/imgs/cityscapes_sample.jpg    | Bin 0 -> 49918 bytes
 tests/imgs/cityscapes_sample2.jpg   | Bin 0 -> 428014 bytes
 tests/{models => }/imgs/dog.jpg     | Bin
 tests/{models => }/imgs/helmet.jpeg | Bin
 tests/models/test_weights.py        |   6 +++---
 5 files changed, 3 insertions(+), 3 deletions(-)
 create mode 100644 tests/imgs/cityscapes_sample.jpg
 create mode 100644 tests/imgs/cityscapes_sample2.jpg
 rename tests/{models => }/imgs/dog.jpg (100%)
 rename tests/{models => }/imgs/helmet.jpeg (100%)

diff --git a/tests/imgs/cityscapes_sample.jpg b/tests/imgs/cityscapes_sample.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..9e401d85aeeb9b3503f7b33fd12bde40b637707e
GIT binary patch
literal 49918
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
JtLIR!|Jmac!h`?-

literal 0
HcmV?d00001

diff --git a/tests/imgs/cityscapes_sample2.jpg b/tests/imgs/cityscapes_sample2.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..c6942a48a34f77a1b59ea881a820d47f0b221e1d
GIT binary patch
literal 428014
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%0DgV+51DM#_+QjxdKXt)FAQ;}J^ky<mujs~=w
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%0DIl`ZRVc2!#0m)Kz
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%0Df_Nm6$Ln7(H0;Te
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
GNB`MX77$Ya

literal 0
HcmV?d00001

diff --git a/tests/models/imgs/dog.jpg b/tests/imgs/dog.jpg
similarity index 100%
rename from tests/models/imgs/dog.jpg
rename to tests/imgs/dog.jpg
diff --git a/tests/models/imgs/helmet.jpeg b/tests/imgs/helmet.jpeg
similarity index 100%
rename from tests/models/imgs/helmet.jpeg
rename to tests/imgs/helmet.jpeg
diff --git a/tests/models/test_weights.py b/tests/models/test_weights.py
index 7687dac..c22c173 100644
--- a/tests/models/test_weights.py
+++ b/tests/models/test_weights.py
@@ -18,8 +18,8 @@
 # tests are made to be run from root project directory
 # format "imagenet_image_class: PIL Image"
 IMGS = {
-    560: Image.open("tests/models/imgs/helmet.jpeg"),
-    207: Image.open("tests/models/imgs/dog.jpg"),
+    560: Image.open("tests/imgs/helmet.jpeg"),
+    207: Image.open("tests/imgs/dog.jpg"),
 }
 
 # временная заглушка. TODO: убрать
@@ -75,4 +75,4 @@ def test_output_mean(arch):
     inp = torch.ones(1, 3, 256, 256)
     with torch.no_grad():
         out = m(inp).mean().numpy()
-    assert np.allclose(out, MODEL_MEAN[arch], rtol=1e-4, atol=1e-4)
\ No newline at end of file
+    assert np.allclose(out, MODEL_MEAN[arch], rtol=1e-4, atol=1e-4)

From df132ff5dba6911a2c017ab5565a66a9ea433dda Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Thu, 21 May 2020 16:54:32 +0300
Subject: [PATCH 31/54] increase version to use torchvision nms

---
 requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/requirements.txt b/requirements.txt
index 3a84f92..39dc412 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,2 +1,2 @@
-torch>=1.1
+torch>=1.4
 inplace-abn
\ No newline at end of file

From ba8e0399bfba2755f87c743d38cb6d1d1e899876 Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Thu, 21 May 2020 18:07:52 +0300
Subject: [PATCH 32/54] minor update to docs

---
 pytorch_tools/detection_models/efficientdet.py | 1 +
 pytorch_tools/utils/box.py                     | 8 ++++++++
 pytorch_tools/utils/visualization.py           | 3 ++-
 3 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/pytorch_tools/detection_models/efficientdet.py b/pytorch_tools/detection_models/efficientdet.py
index dbd617b..cefd7a6 100644
--- a/pytorch_tools/detection_models/efficientdet.py
+++ b/pytorch_tools/detection_models/efficientdet.py
@@ -115,6 +115,7 @@ def forward(self, x):
             class_outputs.append(cls_feat.contiguous().view(cls_feat.shape[0], -1, self.num_classes))
 
             # TODO: return back to simplier transpose operations
+            # This transpose + view aligns with `generate_anchor_boxes` function
             # class_outputs.append(cls_feat.transpose(1, 3).contiguous().view(x.shape[0], -1, self.num_classes))
             # box_outputs.append(box_feat.transpose(1, 3).contiguous().view(x.shape[0], -1, 4))
 
diff --git a/pytorch_tools/utils/box.py b/pytorch_tools/utils/box.py
index 92affe9..f66f96f 100644
--- a/pytorch_tools/utils/box.py
+++ b/pytorch_tools/utils/box.py
@@ -42,6 +42,14 @@ def box_area(box):
     """
     return (box[:, 2] - box[:, 0]) * (box[:, 3] - box[:, 1])
 
+def clip_bboxes(bboxes, size):
+    """Args:
+        bboxes (torch.Tensor): in `ltrb` format. Shape [N, 4]
+        size (Union[torch.Size, tuple]): (H, W)"""
+    bboxes[:, 0::2] = bboxes[:, 0::2].clamp(0, size[1])
+    bboxes[:, 1::2] = bboxes[:, 1::2].clamp(0, size[0])
+    return bboxes
+
 # implementation from https://github.com/kuangliu/torchcv/blob/master/torchcv/utils/box.py
 # with slight modifications
 def box_iou(boxes1, boxes2):
diff --git a/pytorch_tools/utils/visualization.py b/pytorch_tools/utils/visualization.py
index 761554b..592bec3 100644
--- a/pytorch_tools/utils/visualization.py
+++ b/pytorch_tools/utils/visualization.py
@@ -4,7 +4,8 @@
 import numpy as np
 
 
-def tensor_from_rgb_image(image: np.ndarray) -> torch.Tensor:
+def tensor_from_rgb_image(image):
+    """Args: image (np.array): Input image in HxWxC format"""
     image = np.moveaxis(image, -1, 0)
     image = np.ascontiguousarray(image)
     image = torch.from_numpy(image)

From be17775a32c210935eeef5a9b4d49d05f2db0a9b Mon Sep 17 00:00:00 2001
From: bonlime <bonlimezak@gmail.com>
Date: Thu, 21 May 2020 20:39:50 +0300
Subject: [PATCH 33/54] add bit-M-ResNet (#67)

Co-authored-by: zakajd <djamilzak@gmail.com>
---
 pytorch_tools/models/__init__.py   |   7 +
 pytorch_tools/models/bit_resnet.py | 310 +++++++++++++++++++++++++++++
 pytorch_tools/models/resnet.py     |   2 +-
 3 files changed, 318 insertions(+), 1 deletion(-)
 create mode 100644 pytorch_tools/models/bit_resnet.py

diff --git a/pytorch_tools/models/__init__.py b/pytorch_tools/models/__init__.py
index 3f98c2d..ef9c0d4 100644
--- a/pytorch_tools/models/__init__.py
+++ b/pytorch_tools/models/__init__.py
@@ -45,3 +45,10 @@
 from .hrnet import hrnet_w44
 from .hrnet import hrnet_w48
 from .hrnet import hrnet_w64
+
+from .bit_resnet import bit_m_50x1
+from .bit_resnet import bit_m_50x3
+from .bit_resnet import bit_m_101x1
+from .bit_resnet import bit_m_101x3
+from .bit_resnet import bit_m_152x2
+from .bit_resnet import bit_m_152x4
\ No newline at end of file
diff --git a/pytorch_tools/models/bit_resnet.py b/pytorch_tools/models/bit_resnet.py
new file mode 100644
index 0000000..1a12f55
--- /dev/null
+++ b/pytorch_tools/models/bit_resnet.py
@@ -0,0 +1,310 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Lint as: python3
+"""Bottleneck ResNet v2 with GroupNorm and Weight Standardization."""
+import os
+import numpy as np
+from copy import deepcopy
+from functools import wraps
+from urllib.parse import urlparse
+from collections import OrderedDict  # pylint: disable=g-importing-member
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from pytorch_tools.modules.weight_standartization import WS_Conv2d as StdConv2d
+
+
+def conv3x3(cin, cout, stride=1, groups=1, bias=False):
+  return StdConv2d(cin, cout, kernel_size=3, stride=stride,
+                   padding=1, bias=bias, groups=groups)
+
+
+def conv1x1(cin, cout, stride=1, bias=False):
+  return StdConv2d(cin, cout, kernel_size=1, stride=stride,
+                   padding=0, bias=bias)
+
+
+def tf2th(conv_weights):
+  """Possibly convert HWIO to OIHW."""
+  if conv_weights.ndim == 4:
+    conv_weights = conv_weights.transpose([3, 2, 0, 1])
+  return torch.from_numpy(conv_weights)
+
+
+class PreActBottleneck(nn.Module):
+  """Pre-activation (v2) bottleneck block.
+
+  Follows the implementation of "Identity Mappings in Deep Residual Networks":
+  https://github.com/KaimingHe/resnet-1k-layers/blob/master/resnet-pre-act.lua
+
+  Except it puts the stride on 3x3 conv when available.
+  """
+
+  def __init__(self, cin, cout=None, cmid=None, stride=1):
+    super().__init__()
+    cout = cout or cin
+    cmid = cmid or cout//4
+
+    self.gn1 = nn.GroupNorm(32, cin)
+    self.conv1 = conv1x1(cin, cmid)
+    self.gn2 = nn.GroupNorm(32, cmid)
+    self.conv2 = conv3x3(cmid, cmid, stride)  # Original code has it on conv1!!
+    self.gn3 = nn.GroupNorm(32, cmid)
+    self.conv3 = conv1x1(cmid, cout)
+    self.relu = nn.ReLU(inplace=True)
+
+    if (stride != 1 or cin != cout):
+      # Projection also with pre-activation according to paper.
+      self.downsample = conv1x1(cin, cout, stride)
+
+  def forward(self, x):
+    out = self.relu(self.gn1(x))
+
+    # Residual branch
+    residual = x
+    if hasattr(self, 'downsample'):
+      residual = self.downsample(out)
+
+    # Unit's branch
+    out = self.conv1(out)
+    out = self.conv2(self.relu(self.gn2(out)))
+    out = self.conv3(self.relu(self.gn3(out)))
+
+    return out + residual
+
+  def load_from(self, weights, prefix=''):
+    convname = 'standardized_conv2d'
+    with torch.no_grad():
+      self.conv1.weight.copy_(tf2th(weights[f'{prefix}a/{convname}/kernel']))
+      self.conv2.weight.copy_(tf2th(weights[f'{prefix}b/{convname}/kernel']))
+      self.conv3.weight.copy_(tf2th(weights[f'{prefix}c/{convname}/kernel']))
+      self.gn1.weight.copy_(tf2th(weights[f'{prefix}a/group_norm/gamma']))
+      self.gn2.weight.copy_(tf2th(weights[f'{prefix}b/group_norm/gamma']))
+      self.gn3.weight.copy_(tf2th(weights[f'{prefix}c/group_norm/gamma']))
+      self.gn1.bias.copy_(tf2th(weights[f'{prefix}a/group_norm/beta']))
+      self.gn2.bias.copy_(tf2th(weights[f'{prefix}b/group_norm/beta']))
+      self.gn3.bias.copy_(tf2th(weights[f'{prefix}c/group_norm/beta']))
+      if hasattr(self, 'downsample'):
+        w = weights[f'{prefix}a/proj/{convname}/kernel']
+        self.downsample.weight.copy_(tf2th(w))
+
+# this models are designed for trasfer learning only! not for training from scratch
+class ResNetV2(nn.Module):
+  """
+  Implementation of Pre-activation (v2) ResNet mode.
+  Used to create Bit-M-50/101/152x1/2/3/4 models
+  
+  Args:
+    num_classes (int): Number of classification classes. Defaults to 5
+  """
+
+  def __init__(
+    self,
+    block_units,
+    width_factor,
+    # in_channels=3, # TODO: add later
+    num_classes=5, # just a random number
+    # encoder=False, # TODO: add later
+    ):
+    super().__init__()
+    wf = width_factor  # shortcut 'cause we'll use it a lot.
+
+    # The following will be unreadable if we split lines.
+    # pylint: disable=line-too-long
+    self.root = nn.Sequential(OrderedDict([
+        ('conv', StdConv2d(3, 64*wf, kernel_size=7, stride=2, padding=3, bias=False)),
+        ('pad', nn.ConstantPad2d(1, 0)),
+        ('pool', nn.MaxPool2d(kernel_size=3, stride=2, padding=0)),
+        # The following is subtly not the same!
+        # ('pool', nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),
+    ]))
+
+    self.body = nn.Sequential(OrderedDict([
+        ('block1', nn.Sequential(OrderedDict(
+            [('unit01', PreActBottleneck(cin=64*wf, cout=256*wf, cmid=64*wf))] +
+            [(f'unit{i:02d}', PreActBottleneck(cin=256*wf, cout=256*wf, cmid=64*wf)) for i in range(2, block_units[0] + 1)],
+        ))),
+        ('block2', nn.Sequential(OrderedDict(
+            [('unit01', PreActBottleneck(cin=256*wf, cout=512*wf, cmid=128*wf, stride=2))] +
+            [(f'unit{i:02d}', PreActBottleneck(cin=512*wf, cout=512*wf, cmid=128*wf)) for i in range(2, block_units[1] + 1)],
+        ))),
+        ('block3', nn.Sequential(OrderedDict(
+            [('unit01', PreActBottleneck(cin=512*wf, cout=1024*wf, cmid=256*wf, stride=2))] +
+            [(f'unit{i:02d}', PreActBottleneck(cin=1024*wf, cout=1024*wf, cmid=256*wf)) for i in range(2, block_units[2] + 1)],
+        ))),
+        ('block4', nn.Sequential(OrderedDict(
+            [('unit01', PreActBottleneck(cin=1024*wf, cout=2048*wf, cmid=512*wf, stride=2))] +
+            [(f'unit{i:02d}', PreActBottleneck(cin=2048*wf, cout=2048*wf, cmid=512*wf)) for i in range(2, block_units[3] + 1)],
+        ))),
+    ]))
+    # pylint: enable=line-too-long
+
+    self.head = nn.Sequential(OrderedDict([
+        ('gn', nn.GroupNorm(32, 2048*wf)),
+        ('relu', nn.ReLU(inplace=True)),
+        ('avg', nn.AdaptiveAvgPool2d(output_size=1)),
+        ('conv', nn.Conv2d(2048*wf, num_classes, kernel_size=1, bias=True)),
+    ]))
+
+  def features(self, x):
+    return self.body(self.root(x))
+
+  def logits(self, x):
+    return self.head(x)
+
+  def forward(self, x):
+    x = self.logits(self.features(x))
+    assert x.shape[-2:] == (1, 1)  # We should have no spatial shape left.
+    return x[...,0,0]
+
+  def load_from(self, weights, prefix='resnet/'):
+    with torch.no_grad():
+      self.root.conv.weight.copy_(tf2th(weights[f'{prefix}root_block/standardized_conv2d/kernel']))  # pylint: disable=line-too-long
+      self.head.gn.weight.copy_(tf2th(weights[f'{prefix}group_norm/gamma']))
+      self.head.gn.bias.copy_(tf2th(weights[f'{prefix}group_norm/beta']))
+      # always zero_head
+      nn.init.zeros_(self.head.conv.weight)
+      nn.init.zeros_(self.head.conv.bias)
+
+      for bname, block in self.body.named_children():
+        for uname, unit in block.named_children():
+          unit.load_from(weights, prefix=f'{prefix}{bname}/{uname}/')
+
+
+
+
+KNOWN_MODELS = OrderedDict([
+    ('BiT-M-R50x1', lambda *a, **kw: ResNetV2([3, 4, 6, 3], 1, *a, **kw)),
+    ('BiT-M-R50x3', lambda *a, **kw: ResNetV2([3, 4, 6, 3], 3, *a, **kw)),
+    ('BiT-M-R101x1', lambda *a, **kw: ResNetV2([3, 4, 23, 3], 1, *a, **kw)),
+    ('BiT-M-R101x3', lambda *a, **kw: ResNetV2([3, 4, 23, 3], 3, *a, **kw)),
+    ('BiT-M-R152x2', lambda *a, **kw: ResNetV2([3, 8, 36, 3], 2, *a, **kw)),
+    ('BiT-M-R152x4', lambda *a, **kw: ResNetV2([3, 8, 36, 3], 4, *a, **kw)),
+
+    ('BiT-S-R50x1', lambda *a, **kw: ResNetV2([3, 4, 6, 3], 1, *a, **kw)),
+    ('BiT-S-R50x3', lambda *a, **kw: ResNetV2([3, 4, 6, 3], 3, *a, **kw)),
+    ('BiT-S-R101x1', lambda *a, **kw: ResNetV2([3, 4, 23, 3], 1, *a, **kw)),
+    ('BiT-S-R101x3', lambda *a, **kw: ResNetV2([3, 4, 23, 3], 3, *a, **kw)),
+    ('BiT-S-R152x2', lambda *a, **kw: ResNetV2([3, 8, 36, 3], 2, *a, **kw)),
+    ('BiT-S-R152x4', lambda *a, **kw: ResNetV2([3, 8, 36, 3], 4, *a, **kw)),
+])
+
+
+PRETRAIN_SETTINGS = {
+    "input_space": "RGB",
+    "input_size": [3, 448, 448],
+    "input_range": [0, 1],
+    "mean": [0.5, 0.5, 0.5],
+    "std": [0.5, 0.5, 0.5],
+    "num_classes": None,
+}
+
+# fmt: off
+CFGS = {
+  # weights are loaded by default
+  "bit_m_50x1": {
+    "default": {
+      "params": {"block_units": [3, 4, 6, 3], "width_factor": 1},
+      "url": "https://storage.googleapis.com/bit_models/BiT-M-R50x1.npz",
+      **PRETRAIN_SETTINGS
+    },
+  },
+  "bit_m_50x3": {
+    "default": {
+      "params": {"block_units": [3, 4, 6, 3], "width_factor": 3},
+      "url": "https://storage.googleapis.com/bit_models/BiT-M-R50x3.npz",
+      **PRETRAIN_SETTINGS,
+    },
+  },
+  "bit_m_101x1": {
+    "default": {
+      "params": {"block_units": [3, 4, 23, 3], "width_factor": 1},
+      "url": "https://storage.googleapis.com/bit_models/BiT-M-R101x1.npz",
+      **PPRETRAIN_SETTINGS,
+    },
+  },
+  "bit_m_101x3": {
+    "default": {
+      "params": {"block_units": [3, 4, 23, 3], "width_factor": 3},
+      "url": "https://storage.googleapis.com/bit_models/BiT-M-R101x3.npz",
+      **PPRETRAIN_SETTINGS,
+    },
+  },
+  "bit_m_152x2": {
+    "default": {
+      "params": {"block_units": [3, 8, 36, 3], "width_factor": 2},
+      "url": "https://storage.googleapis.com/bit_models/BiT-M-R152x2.npz",
+      **PPRETRAIN_SETTINGS,
+    },
+  },
+  "bit_m_152x4": {
+    "default": {
+      "params": {"block_units": [3, 8, 36, 3], "width_factor": 4},
+      "url": "https://storage.googleapis.com/bit_models/BiT-M-R152x4.npz",
+      **PPRETRAIN_SETTINGS
+    },
+  },
+}
+
+# fmt: on
+def _bit_resnet(arch, pretrained=None, **kwargs):
+  cfgs = deepcopy(CFGS)
+  cfg_settings = cfgs[arch]["default"]
+  cfg_params = cfg_settings.pop("params")
+  cfg_url = cfg_settings.pop("url")
+  kwargs.pop("pretrained", None)
+  kwargs.update(cfg_params)
+  model = ResNetV2(**kwargs)
+  # load weights to torch checkpoints folder
+  try:
+      torch.hub.load_state_dict_from_url(cfg_url)
+  except RuntimeError:
+      pass # to avoid RuntimeError: Only one file(not dir) is allowed in the zipfile
+  filename = os.path.basename(urlparse(cfg_url).path)
+  torch_home = torch.hub._get_torch_home()
+  cached_file = os.path.join(torch_home, 'checkpoints', filename)
+  weights = np.load(cached_file)
+  model.load_from(weights)
+  return model
+
+# only want M versions of models for fine-tuning
+@wraps(ResNetV2)
+def bit_m_50x1(**kwargs):
+  return _bit_resnet("bit_m_50x1", **kwargs)
+
+@wraps(ResNetV2)
+def bit_m_50x3(**kwargs):
+  return _bit_resnet("bit_m_50x3", **kwargs)
+
+@wraps(ResNetV2)
+def bit_m_101x1(**kwargs):
+  return _bit_resnet("bit_m_101x1", **kwargs)
+
+@wraps(ResNetV2)
+def bit_m_101x3(**kwargs):
+  return _bit_resnet("bit_m_101x3", **kwargs)
+
+@wraps(ResNetV2)
+def bit_m_152x2(**kwargs):
+  return _bit_resnet("bit_m_152x2", **kwargs)
+
+@wraps(ResNetV2)
+def bit_m_152x4(**kwargs):
+  return _bit_resnet("bit_m_152x4", **kwargs)
+
+
+
diff --git a/pytorch_tools/models/resnet.py b/pytorch_tools/models/resnet.py
index 8743dea..0490cb6 100644
--- a/pytorch_tools/models/resnet.py
+++ b/pytorch_tools/models/resnet.py
@@ -12,7 +12,7 @@
 
 import torch
 import torch.nn as nn
-from torchvision.models.utils import load_state_dict_from_url
+from torch.hub import load_state_dict_from_url
 
 from pytorch_tools.modules import BasicBlock, Bottleneck
 from pytorch_tools.modules import GlobalPool2d, BlurPool

From b25b4f7a1195f884dcc3dd18d9a07e53d7612adb Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Thu, 21 May 2020 20:52:51 +0300
Subject: [PATCH 34/54] fix typo

---
 pytorch_tools/models/bit_resnet.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/pytorch_tools/models/bit_resnet.py b/pytorch_tools/models/bit_resnet.py
index 1a12f55..3108e97 100644
--- a/pytorch_tools/models/bit_resnet.py
+++ b/pytorch_tools/models/bit_resnet.py
@@ -234,28 +234,28 @@ def load_from(self, weights, prefix='resnet/'):
     "default": {
       "params": {"block_units": [3, 4, 23, 3], "width_factor": 1},
       "url": "https://storage.googleapis.com/bit_models/BiT-M-R101x1.npz",
-      **PPRETRAIN_SETTINGS,
+      **PRETRAIN_SETTINGS,
     },
   },
   "bit_m_101x3": {
     "default": {
       "params": {"block_units": [3, 4, 23, 3], "width_factor": 3},
       "url": "https://storage.googleapis.com/bit_models/BiT-M-R101x3.npz",
-      **PPRETRAIN_SETTINGS,
+      **PRETRAIN_SETTINGS,
     },
   },
   "bit_m_152x2": {
     "default": {
       "params": {"block_units": [3, 8, 36, 3], "width_factor": 2},
       "url": "https://storage.googleapis.com/bit_models/BiT-M-R152x2.npz",
-      **PPRETRAIN_SETTINGS,
+      **PRETRAIN_SETTINGS,
     },
   },
   "bit_m_152x4": {
     "default": {
       "params": {"block_units": [3, 8, 36, 3], "width_factor": 4},
       "url": "https://storage.googleapis.com/bit_models/BiT-M-R152x4.npz",
-      **PPRETRAIN_SETTINGS
+      **PRETRAIN_SETTINGS
     },
   },
 }

From 5ab7368575b47588625ebcf6f7bde0e511e82ec8 Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Fri, 22 May 2020 15:00:27 +0300
Subject: [PATCH 35/54] add accumulate batches

---
 pytorch_tools/fit_wrapper/wrapper.py | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/pytorch_tools/fit_wrapper/wrapper.py b/pytorch_tools/fit_wrapper/wrapper.py
index cb57c77..c769d6e 100644
--- a/pytorch_tools/fit_wrapper/wrapper.py
+++ b/pytorch_tools/fit_wrapper/wrapper.py
@@ -18,10 +18,11 @@ class Runner:
             must have `name` attribute. Defaults to None.
         callbacks (List): List of Callbacks to use. Defaults to ConsoleLogger().
         gradient_clip_val (float): Gradient clipping value. 0 means no clip. Causes ~5% training slowdown
+        accumulate_steps (int): if > 1 uses gradient accumulation across iterations to simulate larger batch size
 
     """
     def __init__(
-        self, model, optimizer, criterion, metrics=None, callbacks=ConsoleLogger(), gradient_clip_val=0
+        self, model, optimizer, criterion, metrics=None, callbacks=ConsoleLogger(), gradient_clip_val=0, accumulate_steps=1,
     ):
         super().__init__()
 
@@ -33,6 +34,7 @@ def __init__(
         self.callbacks = Callbacks(callbacks)
         self.callbacks.set_state(self.state)
         self.gradient_clip_val = gradient_clip_val
+        self.accumulate_steps = accumulate_steps
 
     def fit(
         self, train_loader, steps_per_epoch=None, val_loader=None, val_steps=None, epochs=1, start_epoch=0,
@@ -77,13 +79,15 @@ def _make_step(self):
         output = self.state.model(data)
         self.state.output = output
         loss = self.state.criterion(output, target)
+        loss = loss / self.accumulate_steps
         if self.state.is_train:
-            self.state.optimizer.zero_grad()
             with amp.scale_loss(loss, self.state.optimizer) as scaled_loss:
                 scaled_loss.backward()
             if self.gradient_clip_val > 0:
-                torch.nn.utils.clip_grad_norm_(self.state.model.parameters(), self.gradient_clip_val)
-            self.state.optimizer.step()
+                torch.nn.utils.clip_grad_norm_(amp.master_params(self.state.optimizer), self.gradient_clip_val)
+            if self.state.step % self.accumulate_steps == 0:
+                self.state.optimizer.step()
+                self.state.optimizer.zero_grad()
             torch.cuda.synchronize()
 
         # update metrics

From 305fc4dd1f105e436e5a26bc31161dab56149578 Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Fri, 22 May 2020 15:19:00 +0300
Subject: [PATCH 36/54] add tests. move loss scale to preserve loss for logging

---
 pytorch_tools/fit_wrapper/wrapper.py |  3 +--
 tests/fit_wrapper/test_runner.py     | 40 +++++++++++++++++++---------
 2 files changed, 29 insertions(+), 14 deletions(-)

diff --git a/pytorch_tools/fit_wrapper/wrapper.py b/pytorch_tools/fit_wrapper/wrapper.py
index c769d6e..ddf3764 100644
--- a/pytorch_tools/fit_wrapper/wrapper.py
+++ b/pytorch_tools/fit_wrapper/wrapper.py
@@ -79,9 +79,8 @@ def _make_step(self):
         output = self.state.model(data)
         self.state.output = output
         loss = self.state.criterion(output, target)
-        loss = loss / self.accumulate_steps
         if self.state.is_train:
-            with amp.scale_loss(loss, self.state.optimizer) as scaled_loss:
+            with amp.scale_loss(loss / self.accumulate_steps, self.state.optimizer) as scaled_loss:
                 scaled_loss.backward()
             if self.gradient_clip_val > 0:
                 torch.nn.utils.clip_grad_norm_(amp.master_params(self.state.optimizer), self.gradient_clip_val)
diff --git a/tests/fit_wrapper/test_runner.py b/tests/fit_wrapper/test_runner.py
index 6dd56ca..29232a4 100644
--- a/tests/fit_wrapper/test_runner.py
+++ b/tests/fit_wrapper/test_runner.py
@@ -100,14 +100,35 @@ def test_val_loader():
     runner.fit(TEST_LOADER, epochs=2, steps_per_epoch=100, val_loader=TEST_LOADER, val_steps=200)
 
 
-
 def test_grad_clip_loader():
     runner = Runner(
         model=TEST_MODEL,
         optimizer=TEST_OPTIMIZER,
         criterion=TEST_CRITERION,
         metrics=TEST_METRIC,
-        gradient_clip_val=1.0
+        gradient_clip_val=1.0,
+    )
+    runner.fit(TEST_LOADER, epochs=2)
+
+
+def test_accumulate_steps():
+    runner = Runner(
+        model=TEST_MODEL,
+        optimizer=TEST_OPTIMIZER,
+        criterion=TEST_CRITERION,
+        metrics=TEST_METRIC,
+        accumulate_steps=10,
+    )
+    runner.fit(TEST_LOADER, epochs=2)
+
+
+def test_ModelEma_callback():
+    runner = Runner(
+        model=TEST_MODEL,
+        optimizer=TEST_OPTIMIZER,
+        criterion=TEST_CRITERION,
+        metrics=TEST_METRIC,
+        callbacks=pt_clb.ModelEma(TEST_MODEL),
     )
     runner.fit(TEST_LOADER, epochs=2)
 
@@ -123,9 +144,7 @@ def test_grad_clip_loader():
         pt_clb.Timer(),
         pt_clb.ReduceLROnPlateau(),
         pt_clb.CheckpointSaver(TMP_PATH, save_name="model.chpn"),
-        pt_clb.CheckpointSaver(
-            TMP_PATH, save_name="model.chpn", monitor=TEST_METRIC.name, mode="max"
-        ),
+        pt_clb.CheckpointSaver(TMP_PATH, save_name="model.chpn", monitor=TEST_METRIC.name, mode="max"),
         pt_clb.TensorBoard(log_dir=TMP_PATH),
         pt_clb.TensorBoardWithCM(log_dir=TMP_PATH),
         pt_clb.ConsoleLogger(),
@@ -133,7 +152,6 @@ def test_grad_clip_loader():
         pt_clb.Mixup(0.2, NUM_CLASSES),
         pt_clb.Cutmix(1.0, NUM_CLASSES),
         pt_clb.ScheduledDropout(),
-        pt_clb.ModelEma(decay=0.9999)
     ],
 )
 def test_callback(callback):
@@ -152,19 +170,17 @@ def test_callback(callback):
 )
 def test_segm_callback(callback):
     runner = Runner(
-        model=TEST_SEGM_MODEL,
-        optimizer=TEST_SEGM_OPTIMZER,
-        criterion=TEST_CRITERION,
-        callbacks=callback,
+        model=TEST_SEGM_MODEL, optimizer=TEST_SEGM_OPTIMZER, criterion=TEST_CRITERION, callbacks=callback,
     )
     runner.fit(TEST_SEGM_LOADER, epochs=2)
 
+
 def test_invalid_phases_scheduler_mode():
     runner = Runner(
         model=TEST_MODEL,
         optimizer=TEST_OPTIMIZER,
         criterion=TEST_CRITERION,
-        callbacks=pt_clb.PhasesScheduler([{"ep":[0,1], "lr":[0,1], "mode":"new_mode" },])
+        callbacks=pt_clb.PhasesScheduler([{"ep": [0, 1], "lr": [0, 1], "mode": "new_mode"},]),
     )
     with pytest.raises(ValueError):
-        runner.fit(TEST_LOADER, epochs=2)
\ No newline at end of file
+        runner.fit(TEST_LOADER, epochs=2)

From c38d97b0aff1261f2f283e07769134ad69d9afce Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Mon, 25 May 2020 12:33:49 +0300
Subject: [PATCH 37/54] make swish & mish inplace

---
 pytorch_tools/modules/activations.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pytorch_tools/modules/activations.py b/pytorch_tools/modules/activations.py
index 4719d3c..78bcc41 100644
--- a/pytorch_tools/modules/activations.py
+++ b/pytorch_tools/modules/activations.py
@@ -27,7 +27,7 @@ class ACT(Enum):
 
 @torch.jit.script
 def swish_jit_fwd(x):
-    return x.mul(torch.sigmoid(x))
+    return x.mul_(torch.sigmoid(x))
 
 
 @torch.jit.script
@@ -87,7 +87,7 @@ def forward(self, x):
 
 @torch.jit.script
 def mish_jit_fwd(x):
-    return x.mul(torch.tanh(F.softplus(x)))
+    return x.mul_(torch.tanh(F.softplus(x)))
 
 
 @torch.jit.script

From 0bf0a7cf97e924dfd256b1f455d3e88ab1fe2f7e Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Mon, 25 May 2020 19:47:30 +0300
Subject: [PATCH 38/54] fully working EffDet + tests + pretrained weigths
 loading

---
 .../detection_models/efficientdet.py          | 181 ++++++++++++++++--
 pytorch_tools/models/efficientnet.py          |   2 +-
 pytorch_tools/modules/bifpn.py                |   2 +-
 pytorch_tools/modules/tf_same_ops.py          |  10 +-
 pytorch_tools/utils/box.py                    |  80 ++++++--
 tests/detection_models/test_det_models.py     |  49 +++++
 6 files changed, 283 insertions(+), 41 deletions(-)
 create mode 100644 tests/detection_models/test_det_models.py

diff --git a/pytorch_tools/detection_models/efficientdet.py b/pytorch_tools/detection_models/efficientdet.py
index cefd7a6..11b68a1 100644
--- a/pytorch_tools/detection_models/efficientdet.py
+++ b/pytorch_tools/detection_models/efficientdet.py
@@ -1,5 +1,11 @@
+import logging
+from copy import deepcopy
+from functools import wraps
+
 import torch
 import torch.nn as nn
+from torch.hub import load_state_dict_from_url
+
 from pytorch_tools.modules import ABN
 from pytorch_tools.modules.bifpn import BiFPN
 from pytorch_tools.modules import bn_from_name
@@ -8,8 +14,12 @@
 from pytorch_tools.modules.residual import DepthwiseSeparableConv
 from pytorch_tools.modules.tf_same_ops import conv_to_same_conv
 from pytorch_tools.modules.tf_same_ops import maxpool_to_same_maxpool
+
 from pytorch_tools.segmentation_models.encoders import get_encoder
 
+import pytorch_tools.utils.box as box_utils
+from pytorch_tools.utils.misc import DEFAULT_IMAGENET_SETTINGS
+
 def patch_bn(module):
     """TF ported weights use slightly different eps in BN. Need to adjust for better performance"""
     if isinstance(module, ABN):
@@ -19,6 +29,7 @@ def patch_bn(module):
         patch_bn(m)
 
 class EfficientDet(nn.Module):
+    """TODO: add docstring"""
     def __init__(
         self, 
         encoder_name="efficientnet_b0",
@@ -114,37 +125,165 @@ def forward(self, x):
             cls_feat = cls_feat.permute(0, 2, 3, 1)
             class_outputs.append(cls_feat.contiguous().view(cls_feat.shape[0], -1, self.num_classes))
 
-            # TODO: return back to simplier transpose operations
-            # This transpose + view aligns with `generate_anchor_boxes` function
-            # class_outputs.append(cls_feat.transpose(1, 3).contiguous().view(x.shape[0], -1, self.num_classes))
-            # box_outputs.append(box_feat.transpose(1, 3).contiguous().view(x.shape[0], -1, 4))
-
         class_outputs = torch.cat(class_outputs , 1)
         box_outputs = torch.cat(box_outputs, 1)
+        # my anchors are in [x1, y1, x2,y2] format while pretrained weights are in [y1, x1, y2, x2] format
+        # it may be confusing to reorder x and y every time later so I do it once here. it gives 
+        # compatability with pretrained weigths from Google and doesn't affect training from scratch 
+        box_outputs = box_outputs[..., [1, 0, 3, 2]]
         return class_outputs, box_outputs
 
+    @torch.no_grad()
+    def predict(self, x):
+        """Run forward on given images and decode raw prediction into bboxes"""
+        class_outputs, box_outputs = self.forward(x)
+        anchors = box_utils.generate_anchors_boxes(x.shape[-2:])[0]
+        out_bboxes, out_scores, out_classes = box_utils.decode(
+            class_outputs, box_outputs, anchors, img_shape=x.shape[-2:]
+        )
+        return out_bboxes, out_scores, out_classes
+
+PRETRAIN_SETTINGS = {**DEFAULT_IMAGENET_SETTINGS, "input_size": (512, 512), "crop_pct":1, "num_classes":90}
+
+# fmt: off
+CFGS = {
+  "efficientdet_b0": {
+    "default": {
+      "params": {
+        "encoder_name":"efficientnet_b0",
+        "pyramid_channels":64,
+        "num_fpn_layers":3,
+        "num_head_repeats":3,
+      },
+      **PRETRAIN_SETTINGS,
+    },
+    "coco": {"url": "https://github.com/bonlime/pytorch-tools/releases/download/v0.1.5/efficientdet-d0.pth",},
+  },
+  "efficientdet_b1": {
+    "default": {
+      "params": {
+        "encoder_name":"efficientnet_b1",
+        "pyramid_channels":88,
+        "num_fpn_layers":4,
+        "num_head_repeats":3,
+      },
+      **PRETRAIN_SETTINGS,
+      "input_size": (640, 640),
+    },
+    "coco": {"url": "https://github.com/bonlime/pytorch-tools/releases/download/v0.1.5/efficientdet-d1.pth",},
+  },
+  "efficientdet_b2": {
+    "default": {
+      "params": {
+        "encoder_name":"efficientnet_b2",
+        "pyramid_channels":112,
+        "num_fpn_layers":5,
+        "num_head_repeats":3,
+      },
+      **PRETRAIN_SETTINGS,
+      "input_size": (768, 768),
+    },
+    "coco": {"url": "https://github.com/bonlime/pytorch-tools/releases/download/v0.1.5/efficientdet-d2.pth",},
+  },
+  "efficientdet_b3": {
+    "default": {
+      "params": {
+        "encoder_name":"efficientnet_b3",
+        "pyramid_channels":160,
+        "num_fpn_layers":6,
+        "num_head_repeats":4,
+      },
+      **PRETRAIN_SETTINGS,
+      "input_size": (896, 896),
+    },
+    "coco": {"url": "https://github.com/bonlime/pytorch-tools/releases/download/v0.1.5/efficientdet-d3.pth",},
+  },
+  "efficientdet_b4": {
+    "default": {
+      "params": {
+        "encoder_name":"efficientnet_b4",
+        "pyramid_channels":224,
+        "num_fpn_layers":7,
+        "num_head_repeats":4,
+      },
+      **PRETRAIN_SETTINGS,
+      "input_size": (1024, 1024),
+    },
+    "coco": {"url": "https://github.com/bonlime/pytorch-tools/releases/download/v0.1.5/efficientdet-d4.pth",},
+  },
+  "efficientdet_b5": {
+    "default": {
+      "params": {
+        "encoder_name":"efficientnet_b5",
+        "pyramid_channels":288,
+        "num_fpn_layers":7,
+        "num_head_repeats":4,
+      },
+      **PRETRAIN_SETTINGS,
+      "input_size": (1280, 1280),
+    },
+    "coco": {"url": "https://github.com/bonlime/pytorch-tools/releases/download/v0.1.5/efficientdet-d5.pth",},
+  },
+  "efficientdet_b6": {
+    "default": {
+      "params": {
+        "encoder_name":"efficientnet_b6",
+        "pyramid_channels":384,
+        "num_fpn_layers":8,
+        "num_head_repeats":5,
+      },
+      **PRETRAIN_SETTINGS,
+      "input_size": (1280, 1280),
+    },
+    "coco": {"url": "https://github.com/bonlime/pytorch-tools/releases/download/v0.1.5/efficientdet-d6.pth",},
+  },
+}
+# fmt: on
+
+def _efficientdet(arch, pretrained=None, **kwargs):
+  cfgs = deepcopy(CFGS)
+  cfg_settings = cfgs[arch]["default"]
+  cfg_params = cfg_settings.pop("params")
+  kwargs.update(cfg_params)
+  model = EfficientDet(**kwargs)
+  if pretrained:
+    state_dict = load_state_dict_from_url(cfgs[arch][pretrained]["url"])
+    kwargs_cls = kwargs.get("num_classes", None)
+    if kwargs_cls and kwargs_cls != cfg_settings["num_classes"]:
+      logging.warning(f"Using model pretrained for {cfg_settings['num_classes']} classes with {kwargs_cls} classes. Last layer is initialized randomly")
+      last_conv_name = f"cls_head_convs.{kwargs['num_head_repeats']}.1"
+      state_dict[f"{last_conv_name}.weight"] = model.state_dict()[f"{last_conv_name}.weight"]
+      state_dict[f"{last_conv_name}.bias"] = model.state_dict()[f"{last_conv_name}.bias"]
+    model.load_state_dict(state_dict)
+  setattr(model, "pretrained_settings", cfg_settings)
+  return model
 
+@wraps(EfficientDet)
+def efficientdet_b0(pretrained="coco", **kwargs):
+    return _efficientdet("efficientdet_b0", pretrained, **kwargs)
 
-def efficientdet_b0(**kwargs):
-    return EfficientDet(**kwargs)
+@wraps(EfficientDet)
+def efficientdet_b1(pretrained="coco", **kwargs):
+    return _efficientdet("efficientdet_b1", pretrained, **kwargs)
 
-def efficientdet_b1(**kwargs):
-    return EfficientDet(
-        encoder_name="efficientnet_b1", pyramid_channels=88, num_fpn_layers=4, num_head_repeats=3, **kwargs)
+@wraps(EfficientDet)
+def efficientdet_b2(pretrained="coco", **kwargs):
+    return _efficientdet("efficientdet_b2", pretrained, **kwargs)
 
-def efficientdet_b2(**kwargs):
-    return EfficientDet(encoder_name="efficientnet_b2", pyramid_channels=112, num_fpn_layers=5, num_head_repeats=3, **kwargs)
+@wraps(EfficientDet)
+def efficientdet_b3(pretrained="coco", **kwargs):
+    return _efficientdet("efficientdet_b3", pretrained, **kwargs)
 
-def efficientdet_b3(**kwargs):
-    return EfficientDet(encoder_name="efficientnet_b3", pyramid_channels=160, num_fpn_layers=6, num_head_repeats=4, **kwargs)
+@wraps(EfficientDet)
+def efficientdet_b4(pretrained="coco", **kwargs):
+    return _efficientdet("efficientdet_b4", pretrained, **kwargs)
 
-def efficientdet_b4(**kwargs):
-    return EfficientDet(encoder_name="efficientnet_b4", pyramid_channels=224, num_fpn_layers=7, num_head_repeats=4, **kwargs)
-    
-def efficientdet_b5(**kwargs):
-    return EfficientDet(encoder_name="efficientnet_b5", pyramid_channels=288, num_fpn_layers=7, num_head_repeats=4, **kwargs)
+@wraps(EfficientDet)
+def efficientdet_b5(pretrained="coco", **kwargs):
+    return _efficientdet("efficientdet_b5", pretrained, **kwargs)
 
-def efficientdet_b6(*args, **kwargs):
-    return EfficientDet(encoder_name="efficientnet_b6", pyramid_channels=384, num_fpn_layers=8, num_head_repeats=5, **kwargs)
+@wraps(EfficientDet)
+def efficientdet_b6(pretrained="coco", **kwargs):
+    return _efficientdet("efficientdet_b6", pretrained, **kwargs)
 
 # No B7 because it's the same model as B6 but with larger input
\ No newline at end of file
diff --git a/pytorch_tools/models/efficientnet.py b/pytorch_tools/models/efficientnet.py
index d9ab577..1510c9c 100644
--- a/pytorch_tools/models/efficientnet.py
+++ b/pytorch_tools/models/efficientnet.py
@@ -389,7 +389,7 @@ def patch_bn(module):
         module.eps = 1e-3
     for m in module.children():
         patch_bn(m)
-
+  
 def _efficientnet(arch, pretrained=None, **kwargs):
     cfgs = deepcopy(CFGS)
     cfg_settings = cfgs[arch]["default"]
diff --git a/pytorch_tools/modules/bifpn.py b/pytorch_tools/modules/bifpn.py
index 406df57..abe55a4 100644
--- a/pytorch_tools/modules/bifpn.py
+++ b/pytorch_tools/modules/bifpn.py
@@ -51,7 +51,7 @@ def __init__(self, channels=64, norm_layer=ABN, norm_act="relu"):
         self.down = nn.MaxPool2d(3, stride=2, padding=1) #  padding=1 TODO: change back
         
         # disable attention for large models. This is very dirty way to check that it's B6 & B7. But i don't care
-        Fusion = FastNormalizedFusion if channels < 288 else SumFusion
+        Fusion = SumFusion if channels > 288 else FastNormalizedFusion
 
         # There is no activation in SeparableConvs, instead activation is in fusion layer
         self.fuse_p6_up = Fusion(in_nodes=2, activation=norm_act)
diff --git a/pytorch_tools/modules/tf_same_ops.py b/pytorch_tools/modules/tf_same_ops.py
index 6a5a910..4e7b638 100644
--- a/pytorch_tools/modules/tf_same_ops.py
+++ b/pytorch_tools/modules/tf_same_ops.py
@@ -5,9 +5,7 @@
 import torch.nn.functional as F
 
 class Conv2dSamePadding(nn.Conv2d):
-    """
-    Assymetric padding matching TensorFlow `same`
-    """ 
+    """Assymetric padding matching TensorFlow `same`""" 
     def forward(self, x):
         h, w = x.shape[-2:]
         pad_w = (math.ceil(w / self.stride[1]) - 1) * self.stride[1] - w + self.kernel_size[1]
@@ -17,9 +15,7 @@ def forward(self, x):
 
     
 class MaxPool2dSamePadding(nn.MaxPool2d):
-    """
-    Assymetric padding matching TensorFlow `same`
-    """ 
+    """Assymetric padding matching TensorFlow `same`""" 
     def forward(self, x):
         h, w = x.shape[-2:]
         pad_w = (math.ceil(w / self.stride) - 1) * self.stride - w + self.kernel_size
@@ -29,6 +25,7 @@ def forward(self, x):
 
     
 def conv_to_same_conv(module):
+    """Turn All Conv2d into SameConv2d to match TF padding"""
     module_output = module
     # skip 1x1 convs 
     if isinstance(module, nn.Conv2d) and module.kernel_size[0] != 1:
@@ -55,6 +52,7 @@ def conv_to_same_conv(module):
     return module_output
 
 def maxpool_to_same_maxpool(module):
+    """Turn All MaxPool2d into SameMaxPool2d to match TF padding"""
     module_output = module
     if isinstance(module, nn.MaxPool2d):
         module_output = MaxPool2dSamePadding(
diff --git a/pytorch_tools/utils/box.py b/pytorch_tools/utils/box.py
index f66f96f..09229c0 100644
--- a/pytorch_tools/utils/box.py
+++ b/pytorch_tools/utils/box.py
@@ -29,12 +29,15 @@ def delta2box(deltas, anchors):
         bboxes (torch.Tensor): bboxes obtained from anchors by regression [N, 4]
     """
 
-    anchors_wh = anchors[:, 2:] - anchors[:, :2] + 1
+    anchors_wh = anchors[:, 2:] - anchors[:, :2] # + 1
     ctr = anchors[:, :2] + 0.5 * anchors_wh
     pred_ctr = deltas[:, :2] * anchors_wh + ctr
     pred_wh = torch.exp(deltas[:, 2:]) * anchors_wh
 
-    return torch.cat([pred_ctr - 0.5 * pred_wh, pred_ctr + 0.5 * pred_wh - 1], 1)
+    # TODO: make sure this +- 1 for centers aligns with Detectron implementation
+    # return torch.cat([pred_ctr - 0.5 * pred_wh, pred_ctr + 0.5 * pred_wh - 1], 1)
+    return torch.cat([pred_ctr - 0.5 * pred_wh, pred_ctr + 0.5 * pred_wh], 1)
+
 
 def box_area(box):
     """Args:
@@ -112,25 +115,24 @@ def generate_anchors_boxes(
     # get offsets for anchor boxes for one pixel
     # can rewrite in pure Torch but using np is more convenient. This function usually should only be called once
     num_anchors = len(scale_vals) * len(aspect_ratios)
-    ratio_vals_sq = np.sqrt(np.repeat(aspect_ratios, len(scale_vals)))
-    scale_vals_tiled = np.tile(scale_vals, len(aspect_ratios))[:, np.newaxis]
+    ratio_vals_sq = np.sqrt(np.tile(aspect_ratios, len(scale_vals)))
+    scale_vals = np.repeat(scale_vals, len(aspect_ratios))[:, np.newaxis]
     wh = np.stack([np.ones(num_anchors) * ratio_vals_sq, np.ones(num_anchors) / ratio_vals_sq], axis=1) 
-    lt = - 0.5 * wh * scale_vals_tiled
-    rb = 0.5 * wh * scale_vals_tiled
+    lt = - 0.5 * wh * scale_vals
+    rb = 0.5 * wh * scale_vals
     base_offsets = torch.from_numpy(np.hstack([lt, rb])) # [num_anchors, 4]
     base_offsets = base_offsets.view(-1, 1, 1, 4) # [num_anchors, 1, 1, 4]
-
     # generate anchor boxes for all given strides
     all_anchors = []
     for stride in strides:
-        x, y = torch.meshgrid([torch.arange(stride / 2, image_size[i], stride) for i in range(2)])
+        y, x = torch.meshgrid([torch.arange(stride / 2, image_size[i], stride) for i in range(2)])
         xyxy = torch.stack((x, y, x, y), 2).unsqueeze(0) 
-        anchors = (xyxy + base_offsets * stride).view(-1, 4).contiguous()
+        # permute to match TF EffDet anchors order after reshape
+        anchors = (xyxy + base_offsets * stride).permute(1, 2, 0, 3).reshape(-1, 4)
         all_anchors.append(anchors)
     all_anchors = torch.cat(all_anchors)
     # clip boxes to image. Not sure if we really need to clip them
-    # all_anchors[:, 0::2] = all_anchors[:, 0::2].clamp(0, image_size[0])
-    # all_anchors[:, 1::2] = all_anchors[:, 1::2].clamp(0, image_size[1])
+    # clip_bboxes(all_anchors, image_size)
     return all_anchors, num_anchors
 
 def generate_targets(anchors, batch_gt_boxes, num_classes, matched_iou=0.5, unmatched_iou=0.4):
@@ -227,4 +229,58 @@ def batched_nms(boxes, scores, idxs, iou_threshold):
     offsets = idxs.to(boxes) * (max_coordinate + 1)
     boxes_for_nms = boxes + offsets[:, None]
     keep = torch.ops.torchvision.nms(boxes_for_nms, scores, iou_threshold)
-    return keep
\ No newline at end of file
+    return keep
+
+def decode(batch_cls_head, batch_box_head, anchors, img_shape=None, threshold=0.05, top_n=1000, iou_threshold=0.5):
+    """
+    Decodes raw outputs of a model for easy visualization of bboxes
+    
+    Args: 
+        batch_cls_head (torch.Tensor): shape [BS, *, NUM_CLASSES]
+        batch_box_head (torch.Tensor): shape [BS, *, 4]
+        anchors (torch.Tensor): shape [*, 4]
+        img_shape (Tuple[int]): if given clips predicted bboxes to img height and width
+        threshold (float): minimum score threshold to consider object detected
+        top_n (int): maximum number of objects per image
+        iou_threshold (float): iou_threshold for Non Maximum Supression
+        
+    Returns:
+        out_bboxes (torch.Tensor): bboxes. Shape [BS, TOP_N] If img_shape is not given they are NOT CLIPPED (!)
+        out_scores (torch.Tensor): Probability scores for each bbox. Shape [BS, TOP_N]
+        out_classes (torch.Tensor): Predicted class for each bbox. Shape [BS, TOP_N]
+    """
+    
+    batch_size = batch_cls_head.size(0)
+    anchors = anchors.to(batch_cls_head)
+    out_scores = torch.zeros((batch_size, top_n)).to(batch_cls_head)
+    out_boxes = torch.zeros((batch_size, top_n, 4)).to(batch_cls_head)
+    out_classes = torch.zeros((batch_size, top_n)).to(batch_cls_head)
+    # it has to be raw logits but check anyway to avoid aplying sigmoid twice
+    if batch_cls_head.min() < 0 or batch_cls_head.max() > 1:
+        batch_cls_head = batch_cls_head.sigmoid()
+    
+    for batch in range(batch_size):
+        # get regressed bboxes
+        all_img_bboxes = delta2box(batch_box_head[batch], anchors)
+        if img_shape: # maybe clip
+            all_img_bboxes = clip_bboxes(all_img_bboxes, img_shape)
+        # select at most `top_n` bboxes and from them select with score > threshold
+        max_cls_score, max_cls_idx = batch_cls_head[batch].max(1)
+        top_cls_score, top_cls_idx = max_cls_score.topk(top_n)
+        top_cls_idx = top_cls_idx[top_cls_score > threshold]
+
+        im_scores = max_cls_score[top_cls_idx]
+        im_classes = max_cls_idx[top_cls_idx]
+        im_bboxes = all_img_bboxes[top_cls_idx]
+        
+        # apply NMS
+        nms_idx = batched_nms(im_bboxes, im_scores, im_classes, iou_threshold)
+        im_scores = im_scores[nms_idx]
+        im_classes = im_classes[nms_idx]
+        im_bboxes = im_bboxes[nms_idx]
+        
+        out_scores[batch, :im_scores.size(0)] = im_scores
+        out_classes[batch, :im_classes.size(0)] = im_classes
+        out_boxes[batch, :im_bboxes.size(0)] = im_bboxes
+        
+    return out_boxes, out_scores, out_classes
\ No newline at end of file
diff --git a/tests/detection_models/test_det_models.py b/tests/detection_models/test_det_models.py
new file mode 100644
index 0000000..84435cc
--- /dev/null
+++ b/tests/detection_models/test_det_models.py
@@ -0,0 +1,49 @@
+import torch
+import pytest
+import numpy as np
+from PIL import Image
+from pytorch_tools.utils.preprocessing import get_preprocessing_fn
+from pytorch_tools.utils.visualization import tensor_from_rgb_image
+
+import pytorch_tools as pt
+import pytorch_tools.detection_models as pt_det
+
+# all weights were tested on 05.2020. for now only leave one model for faster tests 
+MODEL_NAMES = [
+    "efficientdet_b0",
+    # "efficientdet_b1",
+    # "efficientdet_b2",
+    # "efficientdet_b3",
+    # "efficientdet_b4",
+    # "efficientdet_b5",
+    # "efficientdet_b6",
+]
+
+# format "coco image class: PIL Image"
+IMGS = {
+    17: Image.open("tests/imgs/dog.jpg"),
+}
+
+INP = torch.ones(1, 3, 512, 512)
+@torch.no_grad()
+def _test_forward(model):
+    return model(INP)
+
+@pytest.mark.parametrize("arch", MODEL_NAMES)
+def test_coco_pretrain(arch):
+    m = pt_det.__dict__[arch](pretrained="coco").cuda()
+    m.eval()
+    # get size of the images used for pretraining
+    inp_size = m.pretrained_settings["input_size"][-1]
+    # get preprocessing fn according to pretrained settings
+    preprocess_fn = get_preprocessing_fn(m.pretrained_settings)
+    for im_cls, im in IMGS.items():
+        im = np.array(im.resize((inp_size, inp_size)))
+        im_t = tensor_from_rgb_image(preprocess_fn(im)).unsqueeze(0).float().cuda()
+        boxes, scores, classes = m.predict(im_t)
+        assert classes[0, 0] == im_cls # check that most confident bbox is correct
+
+@pytest.mark.parametrize("arch", MODEL_NAMES[:1])
+def test_pretrain_custom_num_classes(arch):
+    m = pt_det.__dict__[arch](pretrained="coco", num_classes=80).eval()
+    _test_forward(m)

From 51caf193dbf667165f4163e3161534f3435e9b9c Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Mon, 25 May 2020 19:52:24 +0300
Subject: [PATCH 39/54] format with black

---
 pytorch_tools/detection_models/__init__.py    |  2 +-
 .../detection_models/efficientdet.py          | 96 +++++++++++--------
 pytorch_tools/detection_models/retinanet.py   | 28 +++---
 pytorch_tools/modules/__init__.py             |  1 +
 pytorch_tools/modules/activated_group_norm.py |  9 +-
 pytorch_tools/modules/bifpn.py                | 43 ++++-----
 pytorch_tools/modules/fpn.py                  | 14 +--
 pytorch_tools/modules/pooling.py              |  8 +-
 pytorch_tools/modules/residual.py             | 20 +++-
 pytorch_tools/modules/spatial_ocr_block.py    | 46 ++++-----
 pytorch_tools/modules/tf_same_ops.py          | 24 ++---
 .../modules/weight_standartization.py         | 52 +++++-----
 tests/detection_models/test_det_models.py     |  8 +-
 13 files changed, 188 insertions(+), 163 deletions(-)

diff --git a/pytorch_tools/detection_models/__init__.py b/pytorch_tools/detection_models/__init__.py
index 8f2dd8e..f44058f 100644
--- a/pytorch_tools/detection_models/__init__.py
+++ b/pytorch_tools/detection_models/__init__.py
@@ -5,4 +5,4 @@
 from .efficientdet import efficientdet_b3
 from .efficientdet import efficientdet_b4
 from .efficientdet import efficientdet_b5
-from .efficientdet import efficientdet_b6
\ No newline at end of file
+from .efficientdet import efficientdet_b6
diff --git a/pytorch_tools/detection_models/efficientdet.py b/pytorch_tools/detection_models/efficientdet.py
index 11b68a1..817ad9b 100644
--- a/pytorch_tools/detection_models/efficientdet.py
+++ b/pytorch_tools/detection_models/efficientdet.py
@@ -20,6 +20,7 @@
 import pytorch_tools.utils.box as box_utils
 from pytorch_tools.utils.misc import DEFAULT_IMAGENET_SETTINGS
 
+
 def patch_bn(module):
     """TF ported weights use slightly different eps in BN. Need to adjust for better performance"""
     if isinstance(module, ABN):
@@ -28,10 +29,12 @@ def patch_bn(module):
     for m in module.children():
         patch_bn(m)
 
+
 class EfficientDet(nn.Module):
     """TODO: add docstring"""
+
     def __init__(
-        self, 
+        self,
         encoder_name="efficientnet_b0",
         encoder_weights="imagenet",
         pyramid_channels=64,
@@ -39,12 +42,12 @@ def __init__(
         num_head_repeats=3,
         num_classes=90,
         drop_connect_rate=0,
-        encoder_norm_layer="abn", # TODO: set to frozenabn when ready
+        encoder_norm_layer="abn",  # TODO: set to frozenabn when ready
         encoder_norm_act="swish",
         decoder_norm_layer="abn",
         decoder_norm_act="swish",
         match_tf_same_padding=False,
-        ):
+    ):
         super().__init__()
         self.encoder = get_encoder(
             encoder_name,
@@ -57,9 +60,9 @@ def __init__(
         self.pyramid6 = nn.Sequential(
             conv1x1(self.encoder.out_shapes[0], pyramid_channels, bias=True),
             norm_layer(pyramid_channels, activation="identity"),
-            nn.MaxPool2d(3, stride=2, padding=1)
+            nn.MaxPool2d(3, stride=2, padding=1),
         )
-        self.pyramid7 = nn.MaxPool2d(3, stride=2, padding=1) # in EffDet it's a simple maxpool
+        self.pyramid7 = nn.MaxPool2d(3, stride=2, padding=1)  # in EffDet it's a simple maxpool
 
         self.bifpn = BiFPN(
             self.encoder.out_shapes[:-2],
@@ -75,18 +78,22 @@ def make_head(out_size):
                 layers += [DepthwiseSeparableConv(pyramid_channels, pyramid_channels, use_norm=False)]
             layers += [DepthwiseSeparableConv(pyramid_channels, out_size, use_norm=False)]
             return nn.ModuleList(layers)
-        
+
         def make_head_norm():
-            return nn.ModuleList([
-                nn.ModuleList(
-                    [
-                        norm_layer(pyramid_channels, activation=decoder_norm_act)
-                        for _ in range(num_head_repeats)
-                    ] + [nn.Identity()] # no bn after last depthwise conv
-                )
-                for _ in range(5)
-            ])
-        anchors_per_location = 9 # TODO: maybe allow to pass this arg?
+            return nn.ModuleList(
+                [
+                    nn.ModuleList(
+                        [
+                            norm_layer(pyramid_channels, activation=decoder_norm_act)
+                            for _ in range(num_head_repeats)
+                        ]
+                        + [nn.Identity()]  # no bn after last depthwise conv
+                    )
+                    for _ in range(5)
+                ]
+            )
+
+        anchors_per_location = 9  # TODO: maybe allow to pass this arg?
         self.cls_head_convs = make_head(num_classes * anchors_per_location)
         self.cls_head_norms = make_head_norm()
         self.box_head_convs = make_head(4 * anchors_per_location)
@@ -97,7 +104,6 @@ def make_head_norm():
         if match_tf_same_padding:
             conv_to_same_conv(self)
             maxpool_to_same_maxpool(self)
-            
 
     def forward(self, x):
         # don't use p2 and p1
@@ -108,7 +114,7 @@ def forward(self, x):
         features = [p7, p6, p5, p4, p3]
         # enhance features
         features = self.bifpn(features)
-        # want features from lowest OS to highest to align with `generate_anchors_boxes` function 
+        # want features from lowest OS to highest to align with `generate_anchors_boxes` function
         features = list(reversed(features))
         class_outputs = []
         box_outputs = []
@@ -125,11 +131,11 @@ def forward(self, x):
             cls_feat = cls_feat.permute(0, 2, 3, 1)
             class_outputs.append(cls_feat.contiguous().view(cls_feat.shape[0], -1, self.num_classes))
 
-        class_outputs = torch.cat(class_outputs , 1)
+        class_outputs = torch.cat(class_outputs, 1)
         box_outputs = torch.cat(box_outputs, 1)
         # my anchors are in [x1, y1, x2,y2] format while pretrained weights are in [y1, x1, y2, x2] format
-        # it may be confusing to reorder x and y every time later so I do it once here. it gives 
-        # compatability with pretrained weigths from Google and doesn't affect training from scratch 
+        # it may be confusing to reorder x and y every time later so I do it once here. it gives
+        # compatability with pretrained weigths from Google and doesn't affect training from scratch
         box_outputs = box_outputs[..., [1, 0, 3, 2]]
         return class_outputs, box_outputs
 
@@ -143,7 +149,8 @@ def predict(self, x):
         )
         return out_bboxes, out_scores, out_classes
 
-PRETRAIN_SETTINGS = {**DEFAULT_IMAGENET_SETTINGS, "input_size": (512, 512), "crop_pct":1, "num_classes":90}
+
+PRETRAIN_SETTINGS = {**DEFAULT_IMAGENET_SETTINGS, "input_size": (512, 512), "crop_pct": 1, "num_classes": 90}
 
 # fmt: off
 CFGS = {
@@ -240,50 +247,61 @@ def predict(self, x):
 }
 # fmt: on
 
+
 def _efficientdet(arch, pretrained=None, **kwargs):
-  cfgs = deepcopy(CFGS)
-  cfg_settings = cfgs[arch]["default"]
-  cfg_params = cfg_settings.pop("params")
-  kwargs.update(cfg_params)
-  model = EfficientDet(**kwargs)
-  if pretrained:
-    state_dict = load_state_dict_from_url(cfgs[arch][pretrained]["url"])
-    kwargs_cls = kwargs.get("num_classes", None)
-    if kwargs_cls and kwargs_cls != cfg_settings["num_classes"]:
-      logging.warning(f"Using model pretrained for {cfg_settings['num_classes']} classes with {kwargs_cls} classes. Last layer is initialized randomly")
-      last_conv_name = f"cls_head_convs.{kwargs['num_head_repeats']}.1"
-      state_dict[f"{last_conv_name}.weight"] = model.state_dict()[f"{last_conv_name}.weight"]
-      state_dict[f"{last_conv_name}.bias"] = model.state_dict()[f"{last_conv_name}.bias"]
-    model.load_state_dict(state_dict)
-  setattr(model, "pretrained_settings", cfg_settings)
-  return model
+    cfgs = deepcopy(CFGS)
+    cfg_settings = cfgs[arch]["default"]
+    cfg_params = cfg_settings.pop("params")
+    kwargs.update(cfg_params)
+    model = EfficientDet(**kwargs)
+    if pretrained:
+        state_dict = load_state_dict_from_url(cfgs[arch][pretrained]["url"])
+        kwargs_cls = kwargs.get("num_classes", None)
+        if kwargs_cls and kwargs_cls != cfg_settings["num_classes"]:
+            logging.warning(
+                f"Using model pretrained for {cfg_settings['num_classes']} classes with {kwargs_cls} classes. Last layer is initialized randomly"
+            )
+            last_conv_name = f"cls_head_convs.{kwargs['num_head_repeats']}.1"
+            state_dict[f"{last_conv_name}.weight"] = model.state_dict()[f"{last_conv_name}.weight"]
+            state_dict[f"{last_conv_name}.bias"] = model.state_dict()[f"{last_conv_name}.bias"]
+        model.load_state_dict(state_dict)
+    setattr(model, "pretrained_settings", cfg_settings)
+    return model
+
 
 @wraps(EfficientDet)
 def efficientdet_b0(pretrained="coco", **kwargs):
     return _efficientdet("efficientdet_b0", pretrained, **kwargs)
 
+
 @wraps(EfficientDet)
 def efficientdet_b1(pretrained="coco", **kwargs):
     return _efficientdet("efficientdet_b1", pretrained, **kwargs)
 
+
 @wraps(EfficientDet)
 def efficientdet_b2(pretrained="coco", **kwargs):
     return _efficientdet("efficientdet_b2", pretrained, **kwargs)
 
+
 @wraps(EfficientDet)
 def efficientdet_b3(pretrained="coco", **kwargs):
     return _efficientdet("efficientdet_b3", pretrained, **kwargs)
 
+
 @wraps(EfficientDet)
 def efficientdet_b4(pretrained="coco", **kwargs):
     return _efficientdet("efficientdet_b4", pretrained, **kwargs)
 
+
 @wraps(EfficientDet)
 def efficientdet_b5(pretrained="coco", **kwargs):
     return _efficientdet("efficientdet_b5", pretrained, **kwargs)
 
+
 @wraps(EfficientDet)
 def efficientdet_b6(pretrained="coco", **kwargs):
     return _efficientdet("efficientdet_b6", pretrained, **kwargs)
 
-# No B7 because it's the same model as B6 but with larger input
\ No newline at end of file
+
+# No B7 because it's the same model as B6 but with larger input
diff --git a/pytorch_tools/detection_models/retinanet.py b/pytorch_tools/detection_models/retinanet.py
index e64a12c..575f193 100644
--- a/pytorch_tools/detection_models/retinanet.py
+++ b/pytorch_tools/detection_models/retinanet.py
@@ -1,11 +1,15 @@
 import torch
 import torch.nn as nn
+
 # import torch.nn.functional as F
 from pytorch_tools.modules.fpn import FPN
+
 # from pytorch_tools.modules.bifpn import BiFPN
 from pytorch_tools.modules import bn_from_name
+
 # from pytorch_tools.modules.residual import conv1x1
 from pytorch_tools.modules.residual import conv3x3
+
 # from pytorch_tools.modules.decoder import SegmentationUpsample
 # from pytorch_tools.utils.misc import initialize
 from pytorch_tools.segmentation_models.encoders import get_encoder
@@ -13,15 +17,15 @@
 
 class RetinaNet(nn.Module):
     def __init__(
-        self, 
-        encoder_name="resnet34", 
-        encoder_weights="imagenet", 
-        pyramid_channels=256, 
+        self,
+        encoder_name="resnet34",
+        encoder_weights="imagenet",
+        pyramid_channels=256,
         num_classes=80,
         norm_layer="abn",
         norm_act="relu",
         **encoder_params,
-        ):
+    ):
         super().__init__()
         self.encoder = get_encoder(
             encoder_name,
@@ -33,10 +37,7 @@ def __init__(
         norm_layer = bn_from_name(norm_layer)
         self.pyramid6 = conv3x3(256, 256, 2, bias=True)
         self.pyramid7 = conv3x3(256, 256, 2, bias=True)
-        self.fpn = FPN(
-           self.encoder.out_shapes[:-2],
-           pyramid_channels=pyramid_channels,
-        )
+        self.fpn = FPN(self.encoder.out_shapes[:-2], pyramid_channels=pyramid_channels,)
 
         def make_head(out_size):
             layers = []
@@ -44,7 +45,7 @@ def make_head(out_size):
                 # some implementations don't use BN here but I think it's needed
                 # TODO: test how it affects results
                 # upd. removed norm_layer. maybe change to group_norm later
-                layers += [nn.Conv2d(256, 256, 3, padding=1)] # norm_layer(256, activation=norm_act)
+                layers += [nn.Conv2d(256, 256, 3, padding=1)]  # norm_layer(256, activation=norm_act)
                 # layers += [nn.Conv2d(256, 256, 3, padding=1), nn.ReLU()]
 
             layers += [nn.Conv2d(256, out_size, 3, padding=1)]
@@ -52,7 +53,7 @@ def make_head(out_size):
 
         self.ratios = [1.0, 2.0, 0.5]
         self.scales = [4 * 2 ** (i / 3) for i in range(3)]
-        anchors = len(self.ratios) * len(self.scales) # 9
+        anchors = len(self.ratios) * len(self.scales)  # 9
 
         self.cls_head = make_head(num_classes * anchors)
         self.box_head = make_head(4 * anchors)
@@ -66,7 +67,7 @@ def forward(self, x):
         # coarser FPN levels
         p6 = self.pyramid6(p5)
         p7 = self.pyramid7(p6.relu())
-        # want features from lowest OS to highest to align with `generate_anchors_boxes` function 
+        # want features from lowest OS to highest to align with `generate_anchors_boxes` function
         features = [p3, p4, p5, p6, p7]
         # TODO: (18.03.20) TF implementation has additional BN here before class/box outputs
         class_outputs = []
@@ -79,6 +80,3 @@ def forward(self, x):
         class_outputs = torch.cat(class_outputs, 1)
         box_outputs = torch.cat(box_outputs, 1)
         return class_outputs, box_outputs
-        
-
-        
\ No newline at end of file
diff --git a/pytorch_tools/modules/__init__.py b/pytorch_tools/modules/__init__.py
index ee20f3c..9612fa1 100644
--- a/pytorch_tools/modules/__init__.py
+++ b/pytorch_tools/modules/__init__.py
@@ -24,6 +24,7 @@
 from .activated_group_norm import AGN
 from inplace_abn import InPlaceABN, InPlaceABNSync
 
+
 def bn_from_name(norm_name):
     norm_name = norm_name.lower()
     if norm_name == "abn":
diff --git a/pytorch_tools/modules/activated_group_norm.py b/pytorch_tools/modules/activated_group_norm.py
index 516b8b8..6b06743 100644
--- a/pytorch_tools/modules/activated_group_norm.py
+++ b/pytorch_tools/modules/activated_group_norm.py
@@ -7,6 +7,7 @@
 from .activations import ACT
 from .activations import ACT_FUNC_DICT
 
+
 class AGN(nn.Module):
     """Activated Group Normalization
     This gathers a GroupNorm and an activation function in a single module
@@ -27,13 +28,7 @@ class AGN(nn.Module):
     """
 
     def __init__(
-        self,
-        num_features,
-        num_groups=32,
-        eps=1e-5, 
-        affine=True,
-        activation="relu",
-        activation_param=0.01,
+        self, num_features, num_groups=32, eps=1e-5, affine=True, activation="relu", activation_param=0.01,
     ):
         super(AGN, self).__init__()
         self.num_features = num_features
diff --git a/pytorch_tools/modules/bifpn.py b/pytorch_tools/modules/bifpn.py
index abe55a4..9b73309 100644
--- a/pytorch_tools/modules/bifpn.py
+++ b/pytorch_tools/modules/bifpn.py
@@ -7,11 +7,13 @@
 from .residual import conv1x1
 from . import ABN
 
+
 class FastNormalizedFusion(nn.Module):
     """Combines 2 or 3 feature maps into one with weights.
     Args:
         input_num (int): 2 for intermediate features, 3 for output features
     """
+
     def __init__(self, in_nodes, activation="relu"):
         super().__init__()
         self.weights = nn.Parameter(torch.ones(in_nodes, dtype=torch.float32))
@@ -26,6 +28,7 @@ def forward(self, *features):
         fused_features = sum([p * w for p, w in zip(features, weights)])
         return self.act(fused_features)
 
+
 # need to create weights to allow loading anyway. So inherit from FastNormalizedFusion for simplicity
 class SumFusion(FastNormalizedFusion):
     def forward(self, *features):
@@ -48,8 +51,8 @@ def __init__(self, channels=64, norm_layer=ABN, norm_act="relu"):
         super().__init__()
 
         self.up = nn.Upsample(scale_factor=2, mode="nearest")
-        self.down = nn.MaxPool2d(3, stride=2, padding=1) #  padding=1 TODO: change back
-        
+        self.down = nn.MaxPool2d(3, stride=2, padding=1)  #  padding=1 TODO: change back
+
         # disable attention for large models. This is very dirty way to check that it's B6 & B7. But i don't care
         Fusion = SumFusion if channels > 288 else FastNormalizedFusion
 
@@ -75,13 +78,13 @@ def __init__(self, channels=64, norm_layer=ABN, norm_act="relu"):
         self.p4_out = DepthwiseSeparableConv(channels, channels, **bn_args)
         self.p5_out = DepthwiseSeparableConv(channels, channels, **bn_args)
         self.p6_out = DepthwiseSeparableConv(channels, channels, **bn_args)
-        self.p7_out = DepthwiseSeparableConv(channels, channels, **bn_args)    
-    
+        self.p7_out = DepthwiseSeparableConv(channels, channels, **bn_args)
+
     def forward(self, features):
 
         # p7, p6, p5, p4, p3
         p7_in, p6_in, p5_in, p4_in, p3_in = features
-        
+
         # Top-down pathway (from low res to high res)
         p6_up = self.p6_up(self.fuse_p6_up(p6_in, self.up(p7_in)))
         p5_up = self.p5_up(self.fuse_p5_up(p5_in, self.up(p6_up)))
@@ -96,38 +99,33 @@ def forward(self, features):
 
         return p7_out, p6_out, p5_out, p4_out, p3_out
 
+
 # additionally downsamples the input
 class FirstBiFPNLayer(BiFPNLayer):
     def __init__(self, encoder_channels, channels=64, norm_layer=ABN, norm_act="relu"):
         super().__init__(channels=channels, norm_layer=norm_layer, norm_act=norm_act)
 
-        # TODO: later remove bias from downsample 
+        # TODO: later remove bias from downsample
         self.p5_downsample_1 = nn.Sequential(
-            conv1x1(encoder_channels[0], channels, bias=True), 
-            norm_layer(channels, activation="identity")
+            conv1x1(encoder_channels[0], channels, bias=True), norm_layer(channels, activation="identity")
         )
         self.p4_downsample_1 = nn.Sequential(
-            conv1x1(encoder_channels[1], channels, bias=True),
-            norm_layer(channels, activation="identity")
+            conv1x1(encoder_channels[1], channels, bias=True), norm_layer(channels, activation="identity")
         )
         self.p3_downsample_1 = nn.Sequential(
-            conv1x1(encoder_channels[2], channels, bias=True),
-            norm_layer(channels, activation="identity")
+            conv1x1(encoder_channels[2], channels, bias=True), norm_layer(channels, activation="identity")
         )
 
         # Devil is in the details. In original repo they use 2 different downsamples from encoder channels
-        # it makes sense to preseve more information, but most of implementations in the internet 
+        # it makes sense to preseve more information, but most of implementations in the internet
         # use output of the first downsample
         self.p4_downsample_2 = nn.Sequential(
-            conv1x1(encoder_channels[1], channels, bias=True),
-            norm_layer(channels, activation="identity")
+            conv1x1(encoder_channels[1], channels, bias=True), norm_layer(channels, activation="identity")
         )
         self.p5_downsample_2 = nn.Sequential(
-            conv1x1(encoder_channels[0], channels, bias=True), 
-            norm_layer(channels, activation="identity")
+            conv1x1(encoder_channels[0], channels, bias=True), norm_layer(channels, activation="identity")
         )
-        # only one downsample for p3 
-
+        # only one downsample for p3
 
     def forward(self, features):
 
@@ -155,6 +153,7 @@ def forward(self, features):
 
         return p7_out, p6_out, p5_out, p4_out, p3_out
 
+
 class BiFPN(nn.Sequential):
     """
     Implementation of Bi-directional Feature Pyramid Network
@@ -170,10 +169,10 @@ class BiFPN(nn.Sequential):
     https://arxiv.org/pdf/1911.09070.pdf
     """
 
-    def __init__(self, encoder_channels, pyramid_channels=64, num_layers=1, **bn_args):  
-        # First layer preprocesses raw encoder features 
+    def __init__(self, encoder_channels, pyramid_channels=64, num_layers=1, **bn_args):
+        # First layer preprocesses raw encoder features
         bifpns = [FirstBiFPNLayer(encoder_channels, pyramid_channels, **bn_args)]
         # Apply BiFPN block `num_layers` times
         for _ in range(num_layers - 1):
             bifpns.append(BiFPNLayer(pyramid_channels, **bn_args))
-        super().__init__(*bifpns)
\ No newline at end of file
+        super().__init__(*bifpns)
diff --git a/pytorch_tools/modules/fpn.py b/pytorch_tools/modules/fpn.py
index 2b6ef39..726f7ff 100644
--- a/pytorch_tools/modules/fpn.py
+++ b/pytorch_tools/modules/fpn.py
@@ -4,6 +4,7 @@
 import torch.nn.functional as F
 from .residual import conv1x1, conv3x3
 
+
 class MergeBlock(nn.Module):
     def forward(self, x):
         x, skip = x
@@ -11,6 +12,7 @@ def forward(self, x):
         x += skip
         return x
 
+
 class FPN(nn.Module):
     """Feature Pyramid Network for enhancing high-resolution feature maps with semantic
     meaning from low resolution maps
@@ -25,11 +27,11 @@ class FPN(nn.Module):
     """
 
     def __init__(
-            self,
-            encoder_channels,
-            pyramid_channels=256,
-            num_layers=1,
-            **bn_args, # for compatability only. Not used
+        self,
+        encoder_channels,
+        pyramid_channels=256,
+        num_layers=1,
+        **bn_args,  # for compatability only. Not used
     ):
         super().__init__()
         assert num_layers == 1, "More that 1 layer is not supported in FPN"
@@ -52,4 +54,4 @@ def forward(self, features):
             pyramid_features[idx] = self.merge_block([pyramid_features[idx - 1], pyramid_features[idx]])
         # smooth them after merging
         pyramid_features = [s_conv(feature) for s_conv, feature in zip(self.smooth_convs, pyramid_features)]
-        return pyramid_features
\ No newline at end of file
+        return pyramid_features
diff --git a/pytorch_tools/modules/pooling.py b/pytorch_tools/modules/pooling.py
index 0e8c24d..6a359e6 100644
--- a/pytorch_tools/modules/pooling.py
+++ b/pytorch_tools/modules/pooling.py
@@ -64,6 +64,7 @@ def feat_mult(self):
     def __repr__(self):
         return self.__class__.__name__ + " (" + ", pool_type=" + self.pool_type + ")"
 
+
 # https://github.com/mrT23/TResNet/
 class FastGlobalAvgPool2d(nn.Module):
     def __init__(self, flatten=False):
@@ -89,16 +90,17 @@ class BlurPool(nn.Module):
     def __init__(self, channels=0):
         super(BlurPool, self).__init__()
         self.channels = channels
-        filt = torch.tensor([1., 2., 1.])
+        filt = torch.tensor([1.0, 2.0, 1.0])
         filt = filt[:, None] * filt[None, :]
         filt = filt / torch.sum(filt)
         filt = filt[None, None, :, :].repeat((self.channels, 1, 1, 1))
         self.register_buffer("filt", filt)
 
     def forward(self, inp):
-        inp_pad = F.pad(inp, (1, 1, 1, 1), 'reflect')
+        inp_pad = F.pad(inp, (1, 1, 1, 1), "reflect")
         return F.conv2d(inp_pad, self.filt, stride=2, padding=0, groups=inp.shape[1])
 
+
 # from https://github.com/mrT23/TResNet/
 class SpaceToDepth(nn.Module):
     def forward(self, x):
@@ -107,4 +109,4 @@ def forward(self, x):
         x = x.view(N, C, H // 4, 4, W // 4, 4)  # (N, C, H//bs, bs, W//bs, bs)
         x = x.permute(0, 3, 5, 1, 2, 4).contiguous()  # (N, bs, bs, C, H//bs, W//bs)
         x = x.view(N, C * 16, H // 4, W // 4)  # (N, C*bs^2, H//bs, W//bs)
-        return x
\ No newline at end of file
+        return x
diff --git a/pytorch_tools/modules/residual.py b/pytorch_tools/modules/residual.py
index 2ea7816..6b865d9 100644
--- a/pytorch_tools/modules/residual.py
+++ b/pytorch_tools/modules/residual.py
@@ -47,6 +47,7 @@ def forward(self, x):
         x_se = self.fc2(x_se)
         return x * x_se.sigmoid()
 
+
 class ECAModule(nn.Module):
     """Efficient Channel Attention
     This implementation is different from the paper. I've removed all hyperparameters and 
@@ -56,7 +57,8 @@ class ECAModule(nn.Module):
     https://arxiv.org/abs/1910.03151
 
     """
-    def __init__(self, *args, **kwargs): 
+
+    def __init__(self, *args, **kwargs):
         super().__init__()
         self.pool = FastGlobalAvgPool2d()
         self.conv = nn.Conv1d(1, 1, kernel_size=3, padding=1, bias=False)
@@ -67,6 +69,7 @@ def forward(self, x):
         x_s = x_s.view(x.size(0), -1, 1, 1).sigmoid()
         return x * x_s.expand_as(x)
 
+
 def get_attn(attn_type):
     """Args: attn_type (Uniont[str, None]): Attention type. Supported:
         `se` - Squeeze and Excitation
@@ -79,13 +82,16 @@ def get_attn(attn_type):
     else:
         return ATT_TO_MODULE[attn_type.lower()]
 
+
 class DepthwiseSeparableConv(nn.Sequential):
     """Depthwise separable conv with BN after depthwise & pointwise."""
 
-    def __init__(self, in_channels, out_channels, stride=1, dilation=1, norm_layer=ABN, norm_act="relu", use_norm=True):
+    def __init__(
+        self, in_channels, out_channels, stride=1, dilation=1, norm_layer=ABN, norm_act="relu", use_norm=True
+    ):
         modules = [
             conv3x3(in_channels, in_channels, stride=stride, groups=in_channels, dilation=dilation),
-            conv1x1(in_channels, out_channels, bias=True), # in efficient det they for some reason add bias
+            conv1x1(in_channels, out_channels, bias=True),  # in efficient det they for some reason add bias
             norm_layer(out_channels, activation=norm_act) if use_norm else nn.Identity(),
         ]
         super().__init__(*modules)
@@ -165,6 +171,7 @@ def forward(self, x):
         output = x / self.keep_prob * binary_tensor
         return output
 
+
 class BasicBlock(nn.Module):
     expansion = 1
 
@@ -274,9 +281,11 @@ def forward(self, x):
         out = self.drop_connect(self.se_module(self.bn3(out))) + residual
         return self.final_act(out)
 
+
 # TResnet models use slightly modified versions of BasicBlock and Bottleneck
 # need to adjust for it
 
+
 class TBasicBlock(BasicBlock):
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
@@ -287,11 +296,12 @@ def __init__(self, **kwargs):
         planes = kwargs["planes"]
         self.se_module = SEModule(planes, max(planes // 4, 64))
 
+
 class TBottleneck(Bottleneck):
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
         self.final_act = nn.ReLU(inplace=True)
-        self.bn1.activation_param = 1e-3 # needed for loading weights
+        self.bn1.activation_param = 1e-3  # needed for loading weights
         self.bn2.activation_param = 1e-3
         if not kwargs.get("attn_type") == "se":
             return
@@ -320,4 +330,4 @@ def forward(self, x):
         out = self.conv3(out)
         # avoid 2 inplace ops by chaining into one long op
         out = self.drop_connect(self.bn3(out)) + residual
-        return self.final_act(out)
\ No newline at end of file
+        return self.final_act(out)
diff --git a/pytorch_tools/modules/spatial_ocr_block.py b/pytorch_tools/modules/spatial_ocr_block.py
index cfe5be4..d419f28 100644
--- a/pytorch_tools/modules/spatial_ocr_block.py
+++ b/pytorch_tools/modules/spatial_ocr_block.py
@@ -5,7 +5,7 @@
 ## Copyright (c) 2019
 ##
 ## This source code is licensed under the MIT-style license found in the
-## LICENSE file in the root directory of this source tree 
+## LICENSE file in the root directory of this source tree
 ##+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 ## modified and simplified by @bonlime
 
@@ -24,18 +24,20 @@ class SpatialOCR_Gather(nn.Module):
     Returns:
         torch.Tensor (B x C_2 x C_1 x 1)
     """
+
     def forward(self, feats, probs):
         # C_1 is number of final classes. C_2 in number of features in `feats`
-        probs = probs.view(probs.size(0), probs.size(1), -1) # B x C_1 x H x W => B x C_1 x HW
-        feats = feats.view(feats.size(0), feats.size(1), -1) # B x C_2 x H x W => B x C_2 x HW
-        feats = feats.permute(0, 2, 1) # B x HW x C_2 
-        probs = probs.softmax(dim=2) # B x C_1 x HW
+        probs = probs.view(probs.size(0), probs.size(1), -1)  # B x C_1 x H x W => B x C_1 x HW
+        feats = feats.view(feats.size(0), feats.size(1), -1)  # B x C_2 x H x W => B x C_2 x HW
+        feats = feats.permute(0, 2, 1)  # B x HW x C_2
+        probs = probs.softmax(dim=2)  # B x C_1 x HW
         # B x C_1 x HW @ B x HW x C_2 => B x C_1 x C_2 => B x C_2 x C_1 => B x C_2 x C_1 x 1
         ocr_context = torch.matmul(probs, feats).permute(0, 2, 1).unsqueeze(3)
         return ocr_context
 
+
 # class ObjectAttentionBlock2D(nn.Module):
-'''
+"""
 The basic implementation for object context block
 Input:
     N X C X H X W
@@ -44,7 +46,8 @@ def forward(self, feats, probs):
     key_channels      : the dimension after the key/query transform
 Return:
     N X C X H X W
-'''
+"""
+
 
 class SpatialOCR(nn.Module):
     """
@@ -57,14 +60,8 @@ class SpatialOCR(nn.Module):
         norm_layer (): Normalization layer to use
         norm_act (str): activation to use in `norm_layer`
     """
-    def __init__(
-        self, 
-        in_channels, 
-        key_channels, 
-        out_channels, 
-        norm_layer=ABN,
-        norm_act="relu"
-        ):
+
+    def __init__(self, in_channels, key_channels, out_channels, norm_layer=ABN, norm_act="relu"):
         super().__init__()
 
         self.in_channels = in_channels
@@ -72,28 +69,25 @@ def __init__(
 
         self.f_pixel = nn.Sequential(
             conv1x1(in_channels, key_channels, bias=True),
-            norm_layer(key_channels, activation=norm_act), 
+            norm_layer(key_channels, activation=norm_act),
             conv1x1(key_channels, key_channels, bias=True),
             norm_layer(key_channels, activation=norm_act),
         )
         self.f_object = nn.Sequential(
             conv1x1(in_channels, key_channels, bias=True),
-            norm_layer(key_channels, activation=norm_act), 
+            norm_layer(key_channels, activation=norm_act),
             conv1x1(key_channels, key_channels, bias=True),
             norm_layer(key_channels, activation=norm_act),
         )
         self.f_down = nn.Sequential(
-            conv1x1(in_channels, key_channels, bias=True),
-            norm_layer(key_channels, activation=norm_act), 
+            conv1x1(in_channels, key_channels, bias=True), norm_layer(key_channels, activation=norm_act),
         )
         self.f_up = nn.Sequential(
-            conv1x1(key_channels, in_channels, bias=True),
-            norm_layer(in_channels, activation=norm_act), 
+            conv1x1(key_channels, in_channels, bias=True), norm_layer(in_channels, activation=norm_act),
         )
 
         self.conv_bn = nn.Sequential(
-            conv1x1(2 * in_channels, out_channels, bias=True),
-            norm_layer(out_channels, activation=norm_act),
+            conv1x1(2 * in_channels, out_channels, bias=True), norm_layer(out_channels, activation=norm_act),
         )
 
     def forward(self, feats, proxy_feats):
@@ -112,8 +106,8 @@ def forward(self, feats, proxy_feats):
 
         # sim_map.shape = B x H*W//16 x 256 @ B x 256 x C => B x H*W//16 x C
         sim_map = torch.matmul(query, key)
-        sim_map = (self.key_channels**-.5) * sim_map
-        sim_map = sim_map.softmax(dim=-1)   
+        sim_map = (self.key_channels ** -0.5) * sim_map
+        sim_map = sim_map.softmax(dim=-1)
 
         # add bg context ...
         # context.shape = B x H*W//16 x C @ B x C x 256 => B x H*W//16 x 256
@@ -124,4 +118,4 @@ def forward(self, feats, proxy_feats):
         context = self.f_up(context)
         # concat and project
         output = self.conv_bn(torch.cat([context, feats], 1))
-        return output
\ No newline at end of file
+        return output
diff --git a/pytorch_tools/modules/tf_same_ops.py b/pytorch_tools/modules/tf_same_ops.py
index 4e7b638..c9511b5 100644
--- a/pytorch_tools/modules/tf_same_ops.py
+++ b/pytorch_tools/modules/tf_same_ops.py
@@ -4,8 +4,10 @@
 import torch.nn as nn
 import torch.nn.functional as F
 
+
 class Conv2dSamePadding(nn.Conv2d):
-    """Assymetric padding matching TensorFlow `same`""" 
+    """Assymetric padding matching TensorFlow `same`"""
+
     def forward(self, x):
         h, w = x.shape[-2:]
         pad_w = (math.ceil(w / self.stride[1]) - 1) * self.stride[1] - w + self.kernel_size[1]
@@ -13,9 +15,10 @@ def forward(self, x):
         x = F.pad(x, [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2])
         return super().forward(x)
 
-    
+
 class MaxPool2dSamePadding(nn.MaxPool2d):
-    """Assymetric padding matching TensorFlow `same`""" 
+    """Assymetric padding matching TensorFlow `same`"""
+
     def forward(self, x):
         h, w = x.shape[-2:]
         pad_w = (math.ceil(w / self.stride) - 1) * self.stride - w + self.kernel_size
@@ -23,20 +26,20 @@ def forward(self, x):
         x = F.pad(x, [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2])
         return super().forward(x)
 
-    
+
 def conv_to_same_conv(module):
     """Turn All Conv2d into SameConv2d to match TF padding"""
     module_output = module
-    # skip 1x1 convs 
+    # skip 1x1 convs
     if isinstance(module, nn.Conv2d) and module.kernel_size[0] != 1:
         module_output = Conv2dSamePadding(
             in_channels=module.in_channels,
             out_channels=module.out_channels,
             kernel_size=module.kernel_size,
             stride=module.stride,
-            padding=0, # explicitly set to 0
+            padding=0,  # explicitly set to 0
             dilation=module.dilation,
-            groups=module.groups, 
+            groups=module.groups,
             bias=module.bias is not None,
         )
         with torch.no_grad():
@@ -51,16 +54,15 @@ def conv_to_same_conv(module):
     del module
     return module_output
 
+
 def maxpool_to_same_maxpool(module):
     """Turn All MaxPool2d into SameMaxPool2d to match TF padding"""
     module_output = module
     if isinstance(module, nn.MaxPool2d):
         module_output = MaxPool2dSamePadding(
-            kernel_size=module.kernel_size,
-            stride=module.stride,
-            padding=0, # explicitly set to 0
+            kernel_size=module.kernel_size, stride=module.stride, padding=0,  # explicitly set to 0
         )
     for name, child in module.named_children():
         module_output.add_module(name, maxpool_to_same_maxpool(child))
     del module
-    return module_output
\ No newline at end of file
+    return module_output
diff --git a/pytorch_tools/modules/weight_standartization.py b/pytorch_tools/modules/weight_standartization.py
index 63d0b5d..3e0edd7 100644
--- a/pytorch_tools/modules/weight_standartization.py
+++ b/pytorch_tools/modules/weight_standartization.py
@@ -3,39 +3,39 @@
 import torch.nn.functional as F
 
 # implements idea from `Weight Standardization` paper https://arxiv.org/abs/1903.10520
-# eps is inside sqrt to avoid overflow Idea from https://arxiv.org/abs/1911.05920    
+# eps is inside sqrt to avoid overflow Idea from https://arxiv.org/abs/1911.05920
 class WS_Conv2d(nn.Conv2d):
-
     def forward(self, x):
         weight = self.weight
         var, mean = torch.var_mean(weight, dim=[1, 2, 3], keepdim=True, unbiased=False)
         weight = (weight - mean) / torch.sqrt(var + 1e-7)
         return F.conv2d(x, weight, self.bias, self.stride, self.padding, self.dilation, self.groups)
 
+
 # code from SyncBatchNorm in pytorch
 def conv_to_ws_conv(module):
-        module_output = module
-        if isinstance(module, torch.nn.Conv2d):
-            module_output = WS_Conv2d(
-                in_channels=module.in_channels,
-                out_channels=module.out_channels,
-                kernel_size=module.kernel_size,
-                stride=module.stride,
-                padding=module.padding,
-                dilation=module.dilation,
-                # groups are also present in DepthWiseConvs which we don't want to patch
-                # TODO: fix this
-                groups=module.groups, 
-                bias=module.bias is not None,
-            )
-            with torch.no_grad(): # not sure if torch.no_grad is needed. but just in case
-                module_output.weight.copy_(module.weight)
-                module_output.weight.requires_grad = module.weight.requires_grad
-                if module.bias is not None:
-                    module_output.bias.copy_(module.bias)
-                    module_output.bias.requires_grad = module.bias.requires_grad
+    module_output = module
+    if isinstance(module, torch.nn.Conv2d):
+        module_output = WS_Conv2d(
+            in_channels=module.in_channels,
+            out_channels=module.out_channels,
+            kernel_size=module.kernel_size,
+            stride=module.stride,
+            padding=module.padding,
+            dilation=module.dilation,
+            # groups are also present in DepthWiseConvs which we don't want to patch
+            # TODO: fix this
+            groups=module.groups,
+            bias=module.bias is not None,
+        )
+        with torch.no_grad():  # not sure if torch.no_grad is needed. but just in case
+            module_output.weight.copy_(module.weight)
+            module_output.weight.requires_grad = module.weight.requires_grad
+            if module.bias is not None:
+                module_output.bias.copy_(module.bias)
+                module_output.bias.requires_grad = module.bias.requires_grad
 
-        for name, child in module.named_children():
-            module_output.add_module(name, conv_to_ws_conv(child))
-        del module
-        return module_output
\ No newline at end of file
+    for name, child in module.named_children():
+        module_output.add_module(name, conv_to_ws_conv(child))
+    del module
+    return module_output
diff --git a/tests/detection_models/test_det_models.py b/tests/detection_models/test_det_models.py
index 84435cc..5fc177f 100644
--- a/tests/detection_models/test_det_models.py
+++ b/tests/detection_models/test_det_models.py
@@ -8,7 +8,7 @@
 import pytorch_tools as pt
 import pytorch_tools.detection_models as pt_det
 
-# all weights were tested on 05.2020. for now only leave one model for faster tests 
+# all weights were tested on 05.2020. for now only leave one model for faster tests
 MODEL_NAMES = [
     "efficientdet_b0",
     # "efficientdet_b1",
@@ -25,10 +25,13 @@
 }
 
 INP = torch.ones(1, 3, 512, 512)
+
+
 @torch.no_grad()
 def _test_forward(model):
     return model(INP)
 
+
 @pytest.mark.parametrize("arch", MODEL_NAMES)
 def test_coco_pretrain(arch):
     m = pt_det.__dict__[arch](pretrained="coco").cuda()
@@ -41,7 +44,8 @@ def test_coco_pretrain(arch):
         im = np.array(im.resize((inp_size, inp_size)))
         im_t = tensor_from_rgb_image(preprocess_fn(im)).unsqueeze(0).float().cuda()
         boxes, scores, classes = m.predict(im_t)
-        assert classes[0, 0] == im_cls # check that most confident bbox is correct
+        assert classes[0, 0] == im_cls  # check that most confident bbox is correct
+
 
 @pytest.mark.parametrize("arch", MODEL_NAMES[:1])
 def test_pretrain_custom_num_classes(arch):

From c2883a10732a0e2be358e6a29ab1d05860e634c5 Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Mon, 25 May 2020 19:58:17 +0300
Subject: [PATCH 40/54] fix tests to use TF same padding

---
 tests/detection_models/test_det_models.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/detection_models/test_det_models.py b/tests/detection_models/test_det_models.py
index 5fc177f..19e6a09 100644
--- a/tests/detection_models/test_det_models.py
+++ b/tests/detection_models/test_det_models.py
@@ -34,7 +34,8 @@ def _test_forward(model):
 
 @pytest.mark.parametrize("arch", MODEL_NAMES)
 def test_coco_pretrain(arch):
-    m = pt_det.__dict__[arch](pretrained="coco").cuda()
+    # want TF same padding for better results
+    m = pt_det.__dict__[arch](pretrained="coco", match_tf_same_padding=True).cuda()
     m.eval()
     # get size of the images used for pretraining
     inp_size = m.pretrained_settings["input_size"][-1]

From 655d6ea1bd975f83ffd0d9e38c88e69d23bddee6 Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Tue, 26 May 2020 11:58:55 +0300
Subject: [PATCH 41/54] make swish & mish not inplace again. inplace version is
 incorrect

---
 pytorch_tools/modules/activations.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pytorch_tools/modules/activations.py b/pytorch_tools/modules/activations.py
index 78bcc41..4719d3c 100644
--- a/pytorch_tools/modules/activations.py
+++ b/pytorch_tools/modules/activations.py
@@ -27,7 +27,7 @@ class ACT(Enum):
 
 @torch.jit.script
 def swish_jit_fwd(x):
-    return x.mul_(torch.sigmoid(x))
+    return x.mul(torch.sigmoid(x))
 
 
 @torch.jit.script
@@ -87,7 +87,7 @@ def forward(self, x):
 
 @torch.jit.script
 def mish_jit_fwd(x):
-    return x.mul_(torch.tanh(F.softplus(x)))
+    return x.mul(torch.tanh(F.softplus(x)))
 
 
 @torch.jit.script

From 9951c8576a0fb0ee18abbfab8cd957f94fdaf955 Mon Sep 17 00:00:00 2001
From: bonlime <bonlimezak@gmail.com>
Date: Wed, 27 May 2020 16:47:16 +0300
Subject: [PATCH 42/54] Fully working RetinaNet (#69)

* add Activated No Norm (which is a simple activation)

* fully working Retina matching both mmdetection and TF Tpu versions

* add & update docs

* allow loading weights in RetinaNet

* add tests

* fix typos

Co-authored-by: zakajd <djamilzak@gmail.com>
---
 pytorch_tools/detection_models/__init__.py    |   4 +
 .../detection_models/efficientdet.py          |   4 +
 pytorch_tools/detection_models/retinanet.py   | 181 ++++++++++++++----
 pytorch_tools/modules/__init__.py             |   3 +
 pytorch_tools/modules/activated_batch_norm.py |   4 +
 pytorch_tools/modules/activated_no_norm.py    |  37 ++++
 pytorch_tools/segmentation_models/linknet.py  |   2 +-
 tests/detection_models/test_det_models.py     |  23 ++-
 8 files changed, 211 insertions(+), 47 deletions(-)
 create mode 100644 pytorch_tools/modules/activated_no_norm.py

diff --git a/pytorch_tools/detection_models/__init__.py b/pytorch_tools/detection_models/__init__.py
index f44058f..62c83ad 100644
--- a/pytorch_tools/detection_models/__init__.py
+++ b/pytorch_tools/detection_models/__init__.py
@@ -1,4 +1,8 @@
 from .retinanet import RetinaNet
+from .retinanet import retinanet_r50_fpn
+from .retinanet import retinanet_r101_fpn
+
+from .efficientdet import EfficientDet
 from .efficientdet import efficientdet_b0
 from .efficientdet import efficientdet_b1
 from .efficientdet import efficientdet_b2
diff --git a/pytorch_tools/detection_models/efficientdet.py b/pytorch_tools/detection_models/efficientdet.py
index 817ad9b..24c9442 100644
--- a/pytorch_tools/detection_models/efficientdet.py
+++ b/pytorch_tools/detection_models/efficientdet.py
@@ -35,6 +35,7 @@ class EfficientDet(nn.Module):
 
     def __init__(
         self,
+        pretrained="coco",  # Not used. here for proper signature
         encoder_name="efficientnet_b0",
         encoder_weights="imagenet",
         pyramid_channels=64,
@@ -79,6 +80,9 @@ def make_head(out_size):
             layers += [DepthwiseSeparableConv(pyramid_channels, out_size, use_norm=False)]
             return nn.ModuleList(layers)
 
+        # The convolution layers in the head are shared among all levels, but
+        # each level has its batch normalization to capture the statistical
+        # difference among different levels.
         def make_head_norm():
             return nn.ModuleList(
                 [
diff --git a/pytorch_tools/detection_models/retinanet.py b/pytorch_tools/detection_models/retinanet.py
index 575f193..f179ec7 100644
--- a/pytorch_tools/detection_models/retinanet.py
+++ b/pytorch_tools/detection_models/retinanet.py
@@ -1,82 +1,181 @@
+import logging
+from copy import deepcopy
+from functools import wraps
+
 import torch
 import torch.nn as nn
 
-# import torch.nn.functional as F
 from pytorch_tools.modules.fpn import FPN
-
-# from pytorch_tools.modules.bifpn import BiFPN
 from pytorch_tools.modules import bn_from_name
-
-# from pytorch_tools.modules.residual import conv1x1
 from pytorch_tools.modules.residual import conv3x3
-
-# from pytorch_tools.modules.decoder import SegmentationUpsample
-# from pytorch_tools.utils.misc import initialize
 from pytorch_tools.segmentation_models.encoders import get_encoder
+import pytorch_tools.utils.box as box_utils
+from pytorch_tools.utils.misc import DEFAULT_IMAGENET_SETTINGS
 
 
 class RetinaNet(nn.Module):
+    """RetinaNet 
+    Main difference from other implementations are:
+    * support of any custom encoder from this repo
+    * optional normalization layer in box classification head
+    * ability to freeze batch norm in encoder with one line
+    
+    Args:
+        pretrained (str): one of `coco` or None. if `coco` - load pretrained weights 
+        encoder_name (str): name of classification model (without last dense layers) used as feature
+            extractor to build detection model
+        encoder_weights (str): one of ``None`` (random initialization), ``imagenet`` (pre-trained on ImageNet)
+        pyramid_channels (int): size of features after FPN. Default 256
+        num_classes (int): a number of classes to predict 
+            class_outputs shape is (BS, *, NUM_CLASSES) where each row in * corresponds to one bbox
+        encoder_norm_layer (str): Normalization layer to use in encoder. If using pretrained
+            it should be the same as in pretrained weights
+        encoder_norm_act (str): Activation for normalization layer in encoder
+        decoder_norm_layer (str): Normalization to use in head convolutions. Default (none) is not to use normalization. 
+            Current implementation is optimized for `GroupNorm`, not `BatchNorm` check code for details
+        decoder_norm_act (str): Activation for normalization layer in head convolutions
+    
+    Ref:
+        Focal Loss for Dense Object Detection - https://arxiv.org/abs/1708.02002
+        Mmdetection - https://github.com/open-mmlab/mmdetection/ (at commit b9daf23)
+        TF TPU version - https://github.com/tensorflow/tpu/tree/master/models/official/retinanet
+    """
+
     def __init__(
         self,
-        encoder_name="resnet34",
+        pretrained="coco", # not used here for proper signature
+        encoder_name="resnet50",
         encoder_weights="imagenet",
         pyramid_channels=256,
         num_classes=80,
-        norm_layer="abn",
-        norm_act="relu",
+        # drop_connect_rate=0, # TODO: add
+        encoder_norm_layer="abn",
+        encoder_norm_act="relu",
+        decoder_norm_layer="none",  # None by default to match detectron & mmdet versions
+        decoder_norm_act="relu",
         **encoder_params,
     ):
         super().__init__()
         self.encoder = get_encoder(
             encoder_name,
-            norm_layer=norm_layer,
-            norm_act=norm_act,
+            norm_layer=encoder_norm_layer,
+            norm_act=encoder_norm_act,
             encoder_weights=encoder_weights,
             **encoder_params,
         )
-        norm_layer = bn_from_name(norm_layer)
-        self.pyramid6 = conv3x3(256, 256, 2, bias=True)
-        self.pyramid7 = conv3x3(256, 256, 2, bias=True)
-        self.fpn = FPN(self.encoder.out_shapes[:-2], pyramid_channels=pyramid_channels,)
+        norm_layer = bn_from_name(decoder_norm_layer)
+        self.pyramid6 = nn.Sequential(
+            conv3x3(self.encoder.out_shapes[0], pyramid_channels, 2, bias=True),
+            norm_layer(pyramid_channels, activation="identity"),
+        )
+        self.pyramid7 = nn.Sequential(
+            conv3x3(pyramid_channels, pyramid_channels, 2, bias=True),
+            norm_layer(pyramid_channels, activation="identity"),
+        )
+        self.fpn = FPN(self.encoder.out_shapes[:-2], pyramid_channels=pyramid_channels)
 
-        def make_head(out_size):
+        def make_final_convs():
             layers = []
             for _ in range(4):
-                # some implementations don't use BN here but I think it's needed
-                # TODO: test how it affects results
-                # upd. removed norm_layer. maybe change to group_norm later
-                layers += [nn.Conv2d(256, 256, 3, padding=1)]  # norm_layer(256, activation=norm_act)
-                # layers += [nn.Conv2d(256, 256, 3, padding=1), nn.ReLU()]
-
-            layers += [nn.Conv2d(256, out_size, 3, padding=1)]
+                layers += [conv3x3(pyramid_channels, pyramid_channels, bias=True)]
+                # Norm here is fine for GroupNorm but for BN it should be implemented the other way
+                # see EffDet for example. Maybe need to change this implementation to align with EffDet
+                layers += [norm_layer(pyramid_channels, activation=decoder_norm_act)]
             return nn.Sequential(*layers)
 
-        self.ratios = [1.0, 2.0, 0.5]
-        self.scales = [4 * 2 ** (i / 3) for i in range(3)]
-        anchors = len(self.ratios) * len(self.scales)  # 9
-
-        self.cls_head = make_head(num_classes * anchors)
-        self.box_head = make_head(4 * anchors)
+        anchors_per_location = 9
+        self.cls_convs = make_final_convs()
+        self.cls_head_conv = conv3x3(pyramid_channels, num_classes * anchors_per_location, bias=True)
+        self.box_convs = make_final_convs()
+        self.box_head_conv = conv3x3(pyramid_channels, 4 * anchors_per_location, bias=True)
         self.num_classes = num_classes
 
-    def forward(self, x):
+    # Name from mmdetectin for convenience
+    def extract_features(self, x):
+        """Extract features from backbone + enchance with FPN"""
         # don't use p2 and p1
         p5, p4, p3, _, _ = self.encoder(x)
-        # enhance features
-        p5, p4, p3 = self.fpn([p5, p4, p3])
         # coarser FPN levels
         p6 = self.pyramid6(p5)
-        p7 = self.pyramid7(p6.relu())
+        p7 = self.pyramid7(p6.relu())  # in mmdet there is no relu here. but i think it's needed
+        # enhance features
+        p5, p4, p3 = self.fpn([p5, p4, p3])
         # want features from lowest OS to highest to align with `generate_anchors_boxes` function
         features = [p3, p4, p5, p6, p7]
-        # TODO: (18.03.20) TF implementation has additional BN here before class/box outputs
+        return features
+
+    def forward(self, x):
+        features = self.extract_features(x)
         class_outputs = []
         box_outputs = []
-        for f in features:
-            cls_anchor = self.cls_head(f).transpose(1, 3).contiguous().view(x.shape[0], -1, self.num_classes)
-            box_anchor = self.box_head(f).transpose(1, 3).contiguous().view(x.shape[0], -1, 4)
-            class_outputs.append(cls_anchor)
-            box_outputs.append(box_anchor)
+        for feat in features:
+            cls_feat = self.cls_head_conv(self.cls_convs(feat))
+            box_feat = self.box_head_conv(self.box_convs(feat))
+            cls_feat = cls_feat.permute(0, 2, 3, 1).contiguous().view(x.size(0), -1, self.num_classes)
+            box_feat = box_feat.permute(0, 2, 3, 1).contiguous().view(x.size(0), -1, 4)
+            class_outputs.append(cls_feat)
+            box_outputs.append(box_feat)
         class_outputs = torch.cat(class_outputs, 1)
         box_outputs = torch.cat(box_outputs, 1)
         return class_outputs, box_outputs
+
+    @torch.no_grad()
+    def predict(self, x):
+        """Run forward on given images and decode raw prediction into bboxes"""
+        class_outputs, box_outputs = self.forward(x)
+        anchors = box_utils.generate_anchors_boxes(x.shape[-2:])[0]
+        out_bboxes, out_scores, out_classes = box_utils.decode(
+            class_outputs, box_outputs, anchors, img_shape=x.shape[-2:]
+        )
+        return out_bboxes, out_scores, out_classes
+
+
+# Don't really know input size for the models. 512 is just a guess
+PRETRAIN_SETTINGS = {**DEFAULT_IMAGENET_SETTINGS, "input_size": (512, 512), "crop_pct": 1, "num_classes": 80}
+
+# weights below were ported from caffe to mmdetection and them ported again by @bonlime
+# mmdetection resnet is slightly different (stride 2 in conv1x1 instead of conv3x3)
+# and order of anchors is also different so it's impossible to do inference using this weights but they work
+# much better for transfer learning than starting from imagenet pretrain
+# fmt: off
+CFGS = {
+  "retinanet_r50_fpn": {
+    "default": {"params": {"encoder_name":"resnet50"}, **PRETRAIN_SETTINGS},
+    "coco": {"url": "https://github.com/bonlime/pytorch-tools/releases/download/v0.1.5/retinanet_r50_fpn_3x_coco.pth",},
+  },
+  "retinanet_r101_fpn": {
+    "default": {"params": {"encoder_name":"resnet101"}, **PRETRAIN_SETTINGS},
+    "coco": {"url": "https://github.com/bonlime/pytorch-tools/releases/download/v0.1.5/retinanet_r101_fpn_2x_coco.pth",},
+  },
+}
+# fmt: on
+
+
+def _retinanet(arch, pretrained=None, **kwargs):
+    cfgs = deepcopy(CFGS)
+    cfg_settings = cfgs[arch]["default"]
+    cfg_params = cfg_settings.pop("params")
+    kwargs.update(cfg_params)
+    model = RetinaNet(**kwargs)
+    if pretrained:
+        state_dict = torch.hub.load_state_dict_from_url(cfgs[arch][pretrained]["url"])
+        kwargs_cls = kwargs.get("num_classes", None)
+        if kwargs_cls and kwargs_cls != cfg_settings["num_classes"]:
+            logging.warning(
+                f"Using model pretrained for {cfg_settings['num_classes']} classes with {kwargs_cls} classes. Last layer is initialized randomly"
+            )
+            state_dict["cls_head_conv.weight"] = model.state_dict()["cls_head_conv.weight"]
+            state_dict["cls_head_conv.bias"] = model.state_dict()["cls_head_conv.bias"]
+        model.load_state_dict(state_dict)
+    setattr(model, "pretrained_settings", cfg_settings)
+    return model
+
+
+@wraps(RetinaNet)
+def retinanet_r50_fpn(pretrained="coco", **kwargs):
+    return _retinanet("retinanet_r50_fpn", pretrained, **kwargs)
+
+
+@wraps(RetinaNet)
+def retinanet_r101_fpn(pretrained="coco", **kwargs):
+    return _retinanet("retinanet_r101_fpn", pretrained, **kwargs)
diff --git a/pytorch_tools/modules/__init__.py b/pytorch_tools/modules/__init__.py
index 9612fa1..3a436df 100644
--- a/pytorch_tools/modules/__init__.py
+++ b/pytorch_tools/modules/__init__.py
@@ -22,6 +22,7 @@
 
 from .activated_batch_norm import ABN
 from .activated_group_norm import AGN
+from .activated_no_norm import NoNormAct
 from inplace_abn import InPlaceABN, InPlaceABNSync
 
 
@@ -37,5 +38,7 @@ def bn_from_name(norm_name):
         return partial(ABN, frozen=True)
     elif norm_name in ("agn", "groupnorm", "group_norm"):
         return AGN
+    elif norm_name in ("none",):
+        return NoNormAct
     else:
         raise ValueError(f"Normalization {norm_name} not supported")
diff --git a/pytorch_tools/modules/activated_batch_norm.py b/pytorch_tools/modules/activated_batch_norm.py
index 8a32930..f4e0786 100644
--- a/pytorch_tools/modules/activated_batch_norm.py
+++ b/pytorch_tools/modules/activated_batch_norm.py
@@ -45,6 +45,8 @@ def __init__(
         self.momentum = momentum
         self.activation = ACT(activation)
         self.activation_param = activation_param
+        self.frozen = frozen
+        
         if frozen:
             self.register_buffer("weight", torch.ones(num_features))
             self.register_buffer("bias", torch.zeros(num_features))
@@ -101,4 +103,6 @@ def extra_repr(self):
         rep = "{num_features}, eps={eps}, momentum={momentum}, affine={affine}, activation={activation}"
         if self.activation in ["leaky_relu", "elu"]:
             rep += "[{activation_param}]"
+        if self.frozen:
+            rep += ", frozen=True"
         return rep.format(**self.__dict__)
diff --git a/pytorch_tools/modules/activated_no_norm.py b/pytorch_tools/modules/activated_no_norm.py
new file mode 100644
index 0000000..7271287
--- /dev/null
+++ b/pytorch_tools/modules/activated_no_norm.py
@@ -0,0 +1,37 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.nn import init
+from torch.nn.parameter import Parameter
+
+from .activations import ACT
+from .activations import ACT_FUNC_DICT
+
+
+class NoNormAct(nn.Module):
+    """Activated No Normalization
+    This is just an activation wrapped in class to allow easy swaping with BN and GN
+    Args:
+        num_features (int): Not used. here for compatability
+        activation (str): Name of the activation functions
+        activation_param (float): Negative slope for the `leaky_relu` activation.
+    """
+
+    def __init__(self, num_features, activation="relu", activation_param=0.01):
+        super().__init__()
+        self.num_features = num_features
+        self.activation = ACT(activation)
+        self.activation_param = activation_param
+
+    def forward(self, x):
+        func = ACT_FUNC_DICT[self.activation]
+        if self.activation == ACT.LEAKY_RELU:
+            return func(x, inplace=True, negative_slope=self.activation_param)
+        elif self.activation == ACT.ELU:
+            return func(x, inplace=True, alpha=self.activation_param)
+        else:
+            return func(x, inplace=True)
+
+    def extra_repr(self):
+        rep = "activation={activation}"
+        return rep.format(**self.__dict__)
diff --git a/pytorch_tools/segmentation_models/linknet.py b/pytorch_tools/segmentation_models/linknet.py
index e755c41..e51636d 100644
--- a/pytorch_tools/segmentation_models/linknet.py
+++ b/pytorch_tools/segmentation_models/linknet.py
@@ -52,7 +52,7 @@ class Linknet(EncoderDecoder):
         drop_rate (float): Probability of spatial dropout on last feature map
         norm_layer (str): Normalization layer to use. One of 'abn', 'inplaceabn'. The inplace version lowers memory
             footprint. But increases backward time. Defaults to 'abn'.
-        norm_act (str): Activation for normalizion layer. 'inplaceabn' doesn't support `ReLU` activation.
+        norm_act (str): Activation for normalization layer. 'inplaceabn' doesn't support `ReLU` activation.
     Returns:
         ``torch.nn.Module``: **Linknet**
     .. _Linknet:
diff --git a/tests/detection_models/test_det_models.py b/tests/detection_models/test_det_models.py
index 19e6a09..23715a2 100644
--- a/tests/detection_models/test_det_models.py
+++ b/tests/detection_models/test_det_models.py
@@ -8,15 +8,18 @@
 import pytorch_tools as pt
 import pytorch_tools.detection_models as pt_det
 
+
 # all weights were tested on 05.2020. for now only leave one model for faster tests
 MODEL_NAMES = [
     "efficientdet_b0",
+    "retinanet_r50_fpn",
     # "efficientdet_b1",
     # "efficientdet_b2",
     # "efficientdet_b3",
     # "efficientdet_b4",
     # "efficientdet_b5",
     # "efficientdet_b6",
+    # "retinanet_r101_fpn",
 ]
 
 # format "coco image class: PIL Image"
@@ -24,7 +27,7 @@
     17: Image.open("tests/imgs/dog.jpg"),
 }
 
-INP = torch.ones(1, 3, 512, 512)
+INP = torch.ones(1, 3, 512, 512).cuda()
 
 
 @torch.no_grad()
@@ -35,7 +38,10 @@ def _test_forward(model):
 @pytest.mark.parametrize("arch", MODEL_NAMES)
 def test_coco_pretrain(arch):
     # want TF same padding for better results
-    m = pt_det.__dict__[arch](pretrained="coco", match_tf_same_padding=True).cuda()
+    kwargs = {}
+    if "eff" in arch:
+        kwargs["match_tf_same_padding"] = True
+    m = pt_det.__dict__[arch](pretrained="coco", **kwargs).cuda()
     m.eval()
     # get size of the images used for pretraining
     inp_size = m.pretrained_settings["input_size"][-1]
@@ -45,10 +51,17 @@ def test_coco_pretrain(arch):
         im = np.array(im.resize((inp_size, inp_size)))
         im_t = tensor_from_rgb_image(preprocess_fn(im)).unsqueeze(0).float().cuda()
         boxes, scores, classes = m.predict(im_t)
-        assert classes[0, 0] == im_cls  # check that most confident bbox is correct
+        # check that most confident bbox is close to correct class. The reason for such strange test is 
+        # because in different models class mappings are shifted by +- 1
+        assert (classes[0, 0] - im_cls) < 2
 
 
-@pytest.mark.parametrize("arch", MODEL_NAMES[:1])
+@pytest.mark.parametrize("arch", MODEL_NAMES[:2])
 def test_pretrain_custom_num_classes(arch):
-    m = pt_det.__dict__[arch](pretrained="coco", num_classes=80).eval()
+    m = pt_det.__dict__[arch](pretrained="coco", num_classes=80).eval().cuda()
+    _test_forward(m)
+
+@pytest.mark.parametrize("arch", MODEL_NAMES[:2])
+def test_encoder_frozenabn(arch):
+    m = pt_det.__dict__[arch](encoder_norm_layer="frozenabn").eval().cuda()
     _test_forward(m)

From aea23a1bc16ed816a0f7538b5d6fe30106266a7e Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Fri, 29 May 2020 13:04:28 +0300
Subject: [PATCH 43/54] fix initialization of EffNet models

---
 .../detection_models/efficientdet.py          | 10 +++++++
 pytorch_tools/detection_models/retinanet.py   |  9 ++++++
 pytorch_tools/models/efficientnet.py          |  1 -
 pytorch_tools/utils/misc.py                   | 30 ++++++++++++++-----
 4 files changed, 41 insertions(+), 9 deletions(-)

diff --git a/pytorch_tools/detection_models/efficientdet.py b/pytorch_tools/detection_models/efficientdet.py
index 24c9442..adbe83e 100644
--- a/pytorch_tools/detection_models/efficientdet.py
+++ b/pytorch_tools/detection_models/efficientdet.py
@@ -19,6 +19,7 @@
 
 import pytorch_tools.utils.box as box_utils
 from pytorch_tools.utils.misc import DEFAULT_IMAGENET_SETTINGS
+from pytorch_tools.utils.misc import initialize_iterator
 
 
 def patch_bn(module):
@@ -105,6 +106,7 @@ def make_head_norm():
         self.num_classes = num_classes
 
         patch_bn(self)
+        self._initialize_weights()
         if match_tf_same_padding:
             conv_to_same_conv(self)
             maxpool_to_same_maxpool(self)
@@ -153,6 +155,14 @@ def predict(self, x):
         )
         return out_bboxes, out_scores, out_classes
 
+    def _initialize_weights(self):
+        # init everything except encoder
+        no_encoder_m = [m for n, m in self.named_modules() if not "encoder" in n]
+        initialize_iterator(no_encoder_m)
+        # need to init last bias so that after sigmoid it's 0.01 
+        cls_bias_init = -torch.log(torch.tensor((1 - 0.01) / 0.01)) # -4.59
+        nn.init.constant_(self.cls_head_convs[-1][1].bias, cls_bias_init)
+
 
 PRETRAIN_SETTINGS = {**DEFAULT_IMAGENET_SETTINGS, "input_size": (512, 512), "crop_pct": 1, "num_classes": 90}
 
diff --git a/pytorch_tools/detection_models/retinanet.py b/pytorch_tools/detection_models/retinanet.py
index f179ec7..1ca1078 100644
--- a/pytorch_tools/detection_models/retinanet.py
+++ b/pytorch_tools/detection_models/retinanet.py
@@ -11,6 +11,7 @@
 from pytorch_tools.segmentation_models.encoders import get_encoder
 import pytorch_tools.utils.box as box_utils
 from pytorch_tools.utils.misc import DEFAULT_IMAGENET_SETTINGS
+from pytorch_tools.utils.misc import initialize_iterator
 
 
 class RetinaNet(nn.Module):
@@ -89,6 +90,7 @@ def make_final_convs():
         self.box_convs = make_final_convs()
         self.box_head_conv = conv3x3(pyramid_channels, 4 * anchors_per_location, bias=True)
         self.num_classes = num_classes
+        self. _initialize_weights()
 
     # Name from mmdetectin for convenience
     def extract_features(self, x):
@@ -129,6 +131,13 @@ def predict(self, x):
         )
         return out_bboxes, out_scores, out_classes
 
+    def _initialize_weights(self):
+        # init everything except encoder
+        no_encoder_m = [m for n, m in self.named_modules() if not "encoder" in n]
+        initialize_iterator(no_encoder_m)
+        # need to init last bias so that after sigmoid it's 0.01 
+        cls_bias_init = -torch.log(torch.tensor((1 - 0.01) / 0.01)) # -4.59
+        nn.init.constant_(self.cls_head_conv.bias, cls_bias_init)
 
 # Don't really know input size for the models. 512 is just a guess
 PRETRAIN_SETTINGS = {**DEFAULT_IMAGENET_SETTINGS, "input_size": (512, 512), "crop_pct": 1, "num_classes": 80}
diff --git a/pytorch_tools/models/efficientnet.py b/pytorch_tools/models/efficientnet.py
index 1510c9c..ec6207d 100644
--- a/pytorch_tools/models/efficientnet.py
+++ b/pytorch_tools/models/efficientnet.py
@@ -139,7 +139,6 @@ def __init__(
             self.dropout = nn.Dropout(drop_rate, inplace=True)
             self.classifier = nn.Linear(num_features, num_classes)
 
-        # TODO: change to init from official repo. It may be the source of problem for training from scratch
         initialize(self)
 
     def encoder_features(self, x):
diff --git a/pytorch_tools/utils/misc.py b/pytorch_tools/utils/misc.py
index 72b5fca..cf1fc85 100644
--- a/pytorch_tools/utils/misc.py
+++ b/pytorch_tools/utils/misc.py
@@ -11,15 +11,29 @@
 from functools import partial
 
 
-def initialize(model):
-    for m in model.modules():
-        if isinstance(m, nn.Conv2d):
-            nn.init.kaiming_normal_(m.weight, mode="fan_out", nonlinearity="relu")
-        elif isinstance(m, nn.BatchNorm2d):
-            nn.init.constant_(m.weight, 1)
+def initialize_fn(m):
+    """m (nn.Module): module"""
+    if isinstance(m, nn.Conv2d):
+        # nn.init.kaiming_uniform_ doesn't take into account groups
+        # remove when https://github.com/pytorch/pytorch/issues/23854 is resolved
+        # this is needed for proper init of EffNet models
+        fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+        fan_out //= m.groups
+        m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))
+        if m.bias is not None:
             nn.init.constant_(m.bias, 0)
-        elif isinstance(m, nn.Linear):
-            nn.init.kaiming_uniform_(m.weight, mode="fan_in", nonlinearity="linear")
+    # No check for BN because in PyTorch it is initialized with 1 & 0 by default
+    elif isinstance(m, nn.Linear):
+        nn.init.kaiming_uniform_(m.weight, mode="fan_out", nonlinearity="linear")
+        nn.init.constant_(m.bias, 0)
+
+def initialize(module):
+    for m in module.modules():
+        initialize_fn(m)
+
+def initialize_iterator(module_iterator):
+    for m in module_iterator:
+        initialize_fn(m)
 
 
 def set_random_seed(seed):

From 1258c2cf211afed5e67aebcb4975cff1e51a599a Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Fri, 29 May 2020 19:31:10 +0300
Subject: [PATCH 44/54] fix same MaxPool

---
 pytorch_tools/modules/tf_same_ops.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pytorch_tools/modules/tf_same_ops.py b/pytorch_tools/modules/tf_same_ops.py
index c9511b5..a5b3bd2 100644
--- a/pytorch_tools/modules/tf_same_ops.py
+++ b/pytorch_tools/modules/tf_same_ops.py
@@ -23,7 +23,7 @@ def forward(self, x):
         h, w = x.shape[-2:]
         pad_w = (math.ceil(w / self.stride) - 1) * self.stride - w + self.kernel_size
         pad_h = (math.ceil(h / self.stride) - 1) * self.stride - h + self.kernel_size
-        x = F.pad(x, [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2])
+        x = F.pad(x, [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2], value=-float("inf"))
         return super().forward(x)
 
 

From 22c6b1fffef90c7f76974164302b35a1926dc1cd Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Fri, 29 May 2020 19:31:59 +0300
Subject: [PATCH 45/54] patch BN in effnet by default

---
 pytorch_tools/detection_models/efficientdet.py | 8 +++++++-
 pytorch_tools/models/efficientnet.py           | 2 +-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/pytorch_tools/detection_models/efficientdet.py b/pytorch_tools/detection_models/efficientdet.py
index adbe83e..c0a8776 100644
--- a/pytorch_tools/detection_models/efficientdet.py
+++ b/pytorch_tools/detection_models/efficientdet.py
@@ -111,7 +111,9 @@ def make_head_norm():
             conv_to_same_conv(self)
             maxpool_to_same_maxpool(self)
 
-    def forward(self, x):
+    # Name from mmdetectin for convenience
+    def extract_features(self, x):
+        """Extract features from backbone + enchance with BiFPN"""
         # don't use p2 and p1
         p5, p4, p3, _, _ = self.encoder(x)
         # coarser FPN levels
@@ -122,6 +124,10 @@ def forward(self, x):
         features = self.bifpn(features)
         # want features from lowest OS to highest to align with `generate_anchors_boxes` function
         features = list(reversed(features))
+        return features
+
+    def forward(self, x):
+        features = self.extract_features(x)
         class_outputs = []
         box_outputs = []
         for feat, (cls_bns, box_bns) in zip(features, zip(self.cls_head_norms, self.box_head_norms)):
diff --git a/pytorch_tools/models/efficientnet.py b/pytorch_tools/models/efficientnet.py
index ec6207d..514df3b 100644
--- a/pytorch_tools/models/efficientnet.py
+++ b/pytorch_tools/models/efficientnet.py
@@ -139,6 +139,7 @@ def __init__(
             self.dropout = nn.Dropout(drop_rate, inplace=True)
             self.classifier = nn.Linear(num_features, num_classes)
 
+        patch_bn(self) # adjust epsilon
         initialize(self)
 
     def encoder_features(self, x):
@@ -420,7 +421,6 @@ def _efficientnet(arch, pretrained=None, **kwargs):
         if kwargs.get("in_channels", 3) != 3: # support pretrained for custom input channels
             state_dict["conv_stem.weight"] = repeat_channels(state_dict["conv_stem.weight"], kwargs["in_channels"])
         model.load_state_dict(state_dict)
-        patch_bn(model) # adjust epsilon
     setattr(model, "pretrained_settings", cfg_settings)
     return model
 

From defbab1cf98dd5cc1f66353bbb4aeb864fa699b2 Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Fri, 29 May 2020 19:34:01 +0300
Subject: [PATCH 46/54] change init of last layer for Unet & HRNet

---
 pytorch_tools/segmentation_models/hrnet.py | 16 +++++++++-------
 pytorch_tools/segmentation_models/unet.py  |  7 ++++---
 2 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/pytorch_tools/segmentation_models/hrnet.py b/pytorch_tools/segmentation_models/hrnet.py
index 9690ea9..8e7c3dd 100644
--- a/pytorch_tools/segmentation_models/hrnet.py
+++ b/pytorch_tools/segmentation_models/hrnet.py
@@ -112,8 +112,7 @@ def __init__(
         self.name = f"segm-{encoder_name}"
         # use lower momemntum 
         patch_bn_mom(self)
-        # works better without init (for some reason)
-        # self._init_weights()
+        self._init_weights()
 
     def forward(self, x):
         """Sequentially pass `x` trough model`s `encoder` and `head` (return logits!)"""
@@ -139,12 +138,15 @@ def forward(self, x):
             return x
 
     def _init_weights(self):
-        # init all weights except encoder (to allow pretrain)
-        initialize(self.head)
+        # it works better if we only init last bias not whole decoder part
+        # set last layer bias for better convergence with sigmoid loss 
+        # -4.59 = -np.log((1 - 0.01) / 0.01)
         if self.OCR:
-            initialize(self.aux_head)
-            initialize(self.ocr_distri_head)
-            initialize(self.conv3x3)
+            nn.init.constant_(self.head.bias, -4.59)
+            nn.init.constant_(self.aux_head[2].bias, -4.59)
+        else:
+            nn.init.constant_(self.head[2].bias, -4.59)
+
 
 # fmt: off
 SETTINGS = {
diff --git a/pytorch_tools/segmentation_models/unet.py b/pytorch_tools/segmentation_models/unet.py
index 42eae40..5490a6e 100644
--- a/pytorch_tools/segmentation_models/unet.py
+++ b/pytorch_tools/segmentation_models/unet.py
@@ -40,9 +40,7 @@ def __init__(
         self.layer4 = UnetDecoderBlock(in_channels[3], out_channels[3], **bn_params)
         self.layer5 = UnetDecoderBlock(in_channels[4], out_channels[4], **bn_params)
         self.dropout = nn.Dropout2d(drop_rate, inplace=False) # inplace=True raises a backprop error
-        self.final_conv = conv1x1(out_channels[4], final_channels)
-        # it works much better without initializing decoder. maybe need to investigate into this issue
-        # initialize(self)
+        self.final_conv = conv1x1(out_channels[4], final_channels, bias=True)
 
     def compute_channels(self, encoder_channels, decoder_channels):
         channels = [
@@ -126,3 +124,6 @@ def __init__(
 
         super().__init__(encoder, decoder)
         self.name = f"u-{encoder_name}"
+        # set last layer bias for better convergence with sigmoid loss 
+        # -4.59 = -np.log((1 - 0.01) / 0.01)
+        nn.init.constant_(self.decoder.final_conv.bias, -4.59)
\ No newline at end of file

From 54a91311e8fdeb494671258fdc93489a7fa5ede8 Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Mon, 1 Jun 2020 19:08:30 +0300
Subject: [PATCH 47/54] add TF-like RMSprop

---
 pytorch_tools/optim/__init__.py |  4 ++-
 pytorch_tools/optim/rmsprop.py  | 61 +++++++++++++++++++++++++++++++++
 2 files changed, 64 insertions(+), 1 deletion(-)
 create mode 100644 pytorch_tools/optim/rmsprop.py

diff --git a/pytorch_tools/optim/__init__.py b/pytorch_tools/optim/__init__.py
index bcd9e6d..798ccd9 100644
--- a/pytorch_tools/optim/__init__.py
+++ b/pytorch_tools/optim/__init__.py
@@ -6,6 +6,7 @@
 from .radam import RAdam, PlainRAdam
 from .sgdw import SGDW
 from .schedulers import LinearLR, ExponentialLR
+from .rmsprop import RMSprop
 from .lookahead import Lookahead
 
 from torch import optim
@@ -25,7 +26,8 @@ def optimizer_from_name(optim_name):
         # in this implementation eps in inside sqrt so it can be smaller
         return partial(AdamW_my, center=True, eps=1e-7)
     elif optim_name == "rmsprop":
-        return partial(optim.RMSprop, eps=2e-5)
+        # in this implementation eps in inside sqrt so it can be smaller
+        return partial(RMSprop, eps=1e-7)
     elif optim_name == "radam":
         return partial(RAdam, eps=2e-5)
     elif optim_name in ["fused_sgd", "fusedsgd"]:
diff --git a/pytorch_tools/optim/rmsprop.py b/pytorch_tools/optim/rmsprop.py
new file mode 100644
index 0000000..b1fb033
--- /dev/null
+++ b/pytorch_tools/optim/rmsprop.py
@@ -0,0 +1,61 @@
+"""Implementation of TF-like RMSprop with epsilong inside sqrt. The only difference is at line 52"""
+import torch
+from torch.optim import RMSprop as _RMSprop
+
+class RMSprop(_RMSprop):
+    @torch.no_grad()
+    def step(self, closure=None):
+        """Performs a single optimization step.
+        Arguments:
+            closure (callable, optional): A closure that reevaluates the model
+                and returns the loss.
+        """
+        loss = None
+        if closure is not None:
+            with torch.enable_grad():
+                loss = closure()
+
+        for group in self.param_groups:
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+                grad = p.grad
+                if grad.is_sparse:
+                    raise RuntimeError('RMSprop does not support sparse gradients')
+                state = self.state[p]
+
+                # State initialization
+                if len(state) == 0:
+                    state['step'] = 0
+                    state['square_avg'] = torch.zeros_like(p, memory_format=torch.preserve_format)
+                    if group['momentum'] > 0:
+                        state['momentum_buffer'] = torch.zeros_like(p, memory_format=torch.preserve_format)
+                    if group['centered']:
+                        state['grad_avg'] = torch.zeros_like(p, memory_format=torch.preserve_format)
+
+                square_avg = state['square_avg']
+                alpha = group['alpha']
+
+                state['step'] += 1
+
+                if group['weight_decay'] != 0:
+                    grad = grad.add(p, alpha=group['weight_decay'])
+
+                square_avg.mul_(alpha).addcmul_(grad, grad, value=1 - alpha)
+
+                if group['centered']:
+                    grad_avg = state['grad_avg']
+                    grad_avg.mul_(alpha).add_(grad, alpha=1 - alpha)
+                    avg = square_avg.addcmul(grad_avg, grad_avg, value=-1).sqrt_().add_(group['eps'])
+                else:
+                    # avg = square_avg.sqrt().add_(group['eps'])
+                    avg = square_avg.add_(group['eps']).sqrt()
+
+                if group['momentum'] > 0:
+                    buf = state['momentum_buffer']
+                    buf.mul_(group['momentum']).addcdiv_(grad, avg)
+                    p.add_(buf, alpha=-group['lr'])
+                else:
+                    p.addcdiv_(grad, avg, value=-group['lr'])
+
+        return loss
\ No newline at end of file

From 7c7e331906fd32bf5bd56425d1ae4363f5560400 Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Tue, 2 Jun 2020 14:25:22 +0300
Subject: [PATCH 48/54] also reduce `loss_meter` to save based on reduced loss

---
 pytorch_tools/fit_wrapper/callbacks.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pytorch_tools/fit_wrapper/callbacks.py b/pytorch_tools/fit_wrapper/callbacks.py
index e8d04fb..70bb146 100644
--- a/pytorch_tools/fit_wrapper/callbacks.py
+++ b/pytorch_tools/fit_wrapper/callbacks.py
@@ -530,6 +530,7 @@ def _format_meters(loss, metrics):
     def reduce_metrics(self):
         # can't reduce AverageMeter so need to reduce every attribute separately
         meters = self.state.train_metrics + [self.state.train_loss,]
+        meters = meters + self.state.metric_meters + [self.state.loss_meter,]
         if self.state.val_loss is not None:
             meters = meters + self.state.val_metrics + [self.state.val_loss,]
         reduce_attributes = ["val", "avg", "avg_smooth", "sum", "count"]

From be43c0eedebe6e16bdfb96d797a68c9d7bafda6e Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Wed, 3 Jun 2020 21:42:28 +0300
Subject: [PATCH 49/54] renaming and minor changes

---
 pytorch_tools/detection_models/__init__.py    | 14 +++---
 .../detection_models/efficientdet.py          | 44 +++++++++----------
 pytorch_tools/models/efficientnet.py          |  8 ++++
 pytorch_tools/modules/tf_same_ops.py          |  6 ++-
 pytorch_tools/segmentation_models/README.md   |  2 +-
 5 files changed, 42 insertions(+), 32 deletions(-)

diff --git a/pytorch_tools/detection_models/__init__.py b/pytorch_tools/detection_models/__init__.py
index 62c83ad..04079d7 100644
--- a/pytorch_tools/detection_models/__init__.py
+++ b/pytorch_tools/detection_models/__init__.py
@@ -3,10 +3,10 @@
 from .retinanet import retinanet_r101_fpn
 
 from .efficientdet import EfficientDet
-from .efficientdet import efficientdet_b0
-from .efficientdet import efficientdet_b1
-from .efficientdet import efficientdet_b2
-from .efficientdet import efficientdet_b3
-from .efficientdet import efficientdet_b4
-from .efficientdet import efficientdet_b5
-from .efficientdet import efficientdet_b6
+from .efficientdet import efficientdet_d0
+from .efficientdet import efficientdet_d1
+from .efficientdet import efficientdet_d2
+from .efficientdet import efficientdet_d3
+from .efficientdet import efficientdet_d4
+from .efficientdet import efficientdet_d5
+from .efficientdet import efficientdet_d6
diff --git a/pytorch_tools/detection_models/efficientdet.py b/pytorch_tools/detection_models/efficientdet.py
index c0a8776..5b3c299 100644
--- a/pytorch_tools/detection_models/efficientdet.py
+++ b/pytorch_tools/detection_models/efficientdet.py
@@ -37,7 +37,7 @@ class EfficientDet(nn.Module):
     def __init__(
         self,
         pretrained="coco",  # Not used. here for proper signature
-        encoder_name="efficientnet_b0",
+        encoder_name="efficientnet_d0",
         encoder_weights="imagenet",
         pyramid_channels=64,
         num_fpn_layers=3,
@@ -174,7 +174,7 @@ def _initialize_weights(self):
 
 # fmt: off
 CFGS = {
-  "efficientdet_b0": {
+  "efficientdet_d0": {
     "default": {
       "params": {
         "encoder_name":"efficientnet_b0",
@@ -186,7 +186,7 @@ def _initialize_weights(self):
     },
     "coco": {"url": "https://github.com/bonlime/pytorch-tools/releases/download/v0.1.5/efficientdet-d0.pth",},
   },
-  "efficientdet_b1": {
+  "efficientdet_d1": {
     "default": {
       "params": {
         "encoder_name":"efficientnet_b1",
@@ -199,7 +199,7 @@ def _initialize_weights(self):
     },
     "coco": {"url": "https://github.com/bonlime/pytorch-tools/releases/download/v0.1.5/efficientdet-d1.pth",},
   },
-  "efficientdet_b2": {
+  "efficientdet_d2": {
     "default": {
       "params": {
         "encoder_name":"efficientnet_b2",
@@ -212,7 +212,7 @@ def _initialize_weights(self):
     },
     "coco": {"url": "https://github.com/bonlime/pytorch-tools/releases/download/v0.1.5/efficientdet-d2.pth",},
   },
-  "efficientdet_b3": {
+  "efficientdet_d3": {
     "default": {
       "params": {
         "encoder_name":"efficientnet_b3",
@@ -225,7 +225,7 @@ def _initialize_weights(self):
     },
     "coco": {"url": "https://github.com/bonlime/pytorch-tools/releases/download/v0.1.5/efficientdet-d3.pth",},
   },
-  "efficientdet_b4": {
+  "efficientdet_d4": {
     "default": {
       "params": {
         "encoder_name":"efficientnet_b4",
@@ -238,7 +238,7 @@ def _initialize_weights(self):
     },
     "coco": {"url": "https://github.com/bonlime/pytorch-tools/releases/download/v0.1.5/efficientdet-d4.pth",},
   },
-  "efficientdet_b5": {
+  "efficientdet_d5": {
     "default": {
       "params": {
         "encoder_name":"efficientnet_b5",
@@ -251,7 +251,7 @@ def _initialize_weights(self):
     },
     "coco": {"url": "https://github.com/bonlime/pytorch-tools/releases/download/v0.1.5/efficientdet-d5.pth",},
   },
-  "efficientdet_b6": {
+  "efficientdet_d6": {
     "default": {
       "params": {
         "encoder_name":"efficientnet_b6",
@@ -290,38 +290,38 @@ def _efficientdet(arch, pretrained=None, **kwargs):
 
 
 @wraps(EfficientDet)
-def efficientdet_b0(pretrained="coco", **kwargs):
-    return _efficientdet("efficientdet_b0", pretrained, **kwargs)
+def efficientdet_d0(pretrained="coco", **kwargs):
+    return _efficientdet("efficientdet_d0", pretrained, **kwargs)
 
 
 @wraps(EfficientDet)
-def efficientdet_b1(pretrained="coco", **kwargs):
-    return _efficientdet("efficientdet_b1", pretrained, **kwargs)
+def efficientdet_d1(pretrained="coco", **kwargs):
+    return _efficientdet("efficientdet_d1", pretrained, **kwargs)
 
 
 @wraps(EfficientDet)
-def efficientdet_b2(pretrained="coco", **kwargs):
-    return _efficientdet("efficientdet_b2", pretrained, **kwargs)
+def efficientdet_d2(pretrained="coco", **kwargs):
+    return _efficientdet("efficientdet_d2", pretrained, **kwargs)
 
 
 @wraps(EfficientDet)
-def efficientdet_b3(pretrained="coco", **kwargs):
-    return _efficientdet("efficientdet_b3", pretrained, **kwargs)
+def efficientdet_d3(pretrained="coco", **kwargs):
+    return _efficientdet("efficientdet_d3", pretrained, **kwargs)
 
 
 @wraps(EfficientDet)
-def efficientdet_b4(pretrained="coco", **kwargs):
-    return _efficientdet("efficientdet_b4", pretrained, **kwargs)
+def efficientdet_d4(pretrained="coco", **kwargs):
+    return _efficientdet("efficientdet_d4", pretrained, **kwargs)
 
 
 @wraps(EfficientDet)
-def efficientdet_b5(pretrained="coco", **kwargs):
-    return _efficientdet("efficientdet_b5", pretrained, **kwargs)
+def efficientdet_d5(pretrained="coco", **kwargs):
+    return _efficientdet("efficientdet_d5", pretrained, **kwargs)
 
 
 @wraps(EfficientDet)
-def efficientdet_b6(pretrained="coco", **kwargs):
-    return _efficientdet("efficientdet_b6", pretrained, **kwargs)
+def efficientdet_d6(pretrained="coco", **kwargs):
+    return _efficientdet("efficientdet_d6", pretrained, **kwargs)
 
 
 # No B7 because it's the same model as B6 but with larger input
diff --git a/pytorch_tools/models/efficientnet.py b/pytorch_tools/models/efficientnet.py
index 514df3b..ca5e337 100644
--- a/pytorch_tools/models/efficientnet.py
+++ b/pytorch_tools/models/efficientnet.py
@@ -24,6 +24,8 @@
 from pytorch_tools.modules import bn_from_name
 from pytorch_tools.modules.residual import InvertedResidual
 from pytorch_tools.modules.residual import conv1x1, conv3x3
+from pytorch_tools.modules.tf_same_ops import conv_to_same_conv
+from pytorch_tools.modules.tf_same_ops import maxpool_to_same_maxpool
 from pytorch_tools.utils.misc import initialize
 from pytorch_tools.utils.misc import add_docs_for
 from pytorch_tools.utils.misc import make_divisible
@@ -70,6 +72,8 @@ class EfficientNet(nn.Module):
             But increases backward time and doesn't support `swish` activation. Defaults to 'abn'.
         norm_act (str):
             Activation for normalizion layer. It's reccomended to use `leacky_relu` with `inplaceabn`. Defaults to `swish`
+        match_tf_same_padding (bool): If True patches Conv and MaxPool to implements tf-like asymmetric padding
+            Should only be used to validate pretrained weights. Not needed for training. Gives ~10% slowdown 
     """
 
     def __init__(
@@ -87,6 +91,7 @@ def __init__(
         stem_size=32,
         norm_layer="abn",
         norm_act="swish",
+        match_tf_same_padding=False,
     ):
         super().__init__()
         norm_layer = bn_from_name(norm_layer)
@@ -141,6 +146,9 @@ def __init__(
 
         patch_bn(self) # adjust epsilon
         initialize(self)
+        if match_tf_same_padding:
+            conv_to_same_conv(self)
+            maxpool_to_same_maxpool(self)
 
     def encoder_features(self, x):
         x0 = self.conv_stem(x)
diff --git a/pytorch_tools/modules/tf_same_ops.py b/pytorch_tools/modules/tf_same_ops.py
index a5b3bd2..2ce7e0f 100644
--- a/pytorch_tools/modules/tf_same_ops.py
+++ b/pytorch_tools/modules/tf_same_ops.py
@@ -12,7 +12,8 @@ def forward(self, x):
         h, w = x.shape[-2:]
         pad_w = (math.ceil(w / self.stride[1]) - 1) * self.stride[1] - w + self.kernel_size[1]
         pad_h = (math.ceil(h / self.stride[0]) - 1) * self.stride[0] - h + self.kernel_size[0]
-        x = F.pad(x, [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2])
+        if pad_w > 0 or pad_h > 0:
+            x = F.pad(x, [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2])
         return super().forward(x)
 
 
@@ -23,7 +24,8 @@ def forward(self, x):
         h, w = x.shape[-2:]
         pad_w = (math.ceil(w / self.stride) - 1) * self.stride - w + self.kernel_size
         pad_h = (math.ceil(h / self.stride) - 1) * self.stride - h + self.kernel_size
-        x = F.pad(x, [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2], value=-float("inf"))
+        if pad_w > 0 or pad_h > 0:
+            x = F.pad(x, [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2], value=-float("inf"))
         return super().forward(x)
 
 
diff --git a/pytorch_tools/segmentation_models/README.md b/pytorch_tools/segmentation_models/README.md
index e31e395..b9ca9f7 100644
--- a/pytorch_tools/segmentation_models/README.md
+++ b/pytorch_tools/segmentation_models/README.md
@@ -4,7 +4,7 @@ All models here use `Activated Normalization` layers instead of traditional `Nor
 
 
 ## Encoders 
-All [models](./pytorch_tools/models/) could be used as feature extractors (aka backbones) for segmentation architectures. Almost all combinations of backbones and segm.model are supported.
+All [models](../models/) could be used as feature extractors (aka backbones) for segmentation architectures. Almost all combinations of backbones and segm.model are supported.
 
 
 ## Features

From 1e69ec30ea9a1773f45c3544be57c405cab74c20 Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Wed, 3 Jun 2020 21:59:56 +0300
Subject: [PATCH 50/54] rework some box utils and cover with tests

---
 pytorch_tools/utils/box.py                | 192 ++++++++++++++++------
 tests/detection_models/test_det_models.py |  18 +-
 tests/utils/test_utils.py                 | 125 ++++++++++++++
 3 files changed, 273 insertions(+), 62 deletions(-)
 create mode 100644 tests/utils/test_utils.py

diff --git a/pytorch_tools/utils/box.py b/pytorch_tools/utils/box.py
index 09229c0..f48a86d 100644
--- a/pytorch_tools/utils/box.py
+++ b/pytorch_tools/utils/box.py
@@ -1,61 +1,90 @@
 """Various functions to help with bboxes"""
 import torch
 import numpy as np
+from functools import wraps
 
 def box2delta(boxes, anchors):
+    # type: (Tensor, Tensor)->Tensor
     """Convert boxes to deltas from anchors. Boxes are expected in 'ltrb' format
     Args:
-        boxes (torch.Tensor): shape [N, 4]
-        anchors (torch.Tensor): shape [N, 4]
+        boxes (torch.Tensor): shape [N, 4] or [BS, N, 4]
+        anchors (torch.Tensor): shape [N, 4] or [BS, N, 4]
     Returns:
-        deltas (torch.Tensor): shape [N, 4]. offset_x, offset_y, scale_x, scale_y
+        deltas (torch.Tensor): shape [N, 4] or [BS, N, 4]
+            offset_x, offset_y, scale_x, scale_y
     """
 
-    anchors_wh = anchors[:, 2:] - anchors[:, :2] + 1
-    anchors_ctr = anchors[:, :2] + 0.5 * anchors_wh
-    boxes_wh = boxes[:, 2:] - boxes[:, :2] + 1
-    boxes_ctr = boxes[:, :2] + 0.5 * boxes_wh
+    anchors_wh = anchors[..., 2:] - anchors[..., :2] # + 1
+    anchors_ctr = anchors[..., :2] + 0.5 * anchors_wh
+    boxes_wh = boxes[..., 2:] - boxes[..., :2] # + 1
+    boxes_ctr = boxes[..., :2] + 0.5 * boxes_wh
     offset_delta = (boxes_ctr - anchors_ctr) / anchors_wh
     scale_delta = torch.log(boxes_wh / anchors_wh)
-    return torch.cat([offset_delta, scale_delta], 1)
+    cat_dim = boxes.dim() - 1 # 1 if [N, 4] else [BS, N, 4]
+    return torch.cat([offset_delta, scale_delta], cat_dim)
 
 
 def delta2box(deltas, anchors):
+    # type: (Tensor, Tensor)->Tensor
     """Convert anchors to boxes using deltas. Boxes are expected in 'ltrb' format
     Args:
-        deltas (torch.Tensor): shape [N, 4]. 
-        anchors (torch.Tensor): shape [N, 4]
+        deltas (torch.Tensor): shape [N, 4] or [BS, N, 4]
+        anchors (torch.Tensor): shape [N, 4] or [BS, N, 4]
     Returns:
-        bboxes (torch.Tensor): bboxes obtained from anchors by regression [N, 4]
+        bboxes (torch.Tensor): bboxes obtained from anchors by regression 
+            Output shape is [N, 4] or [BS, N, 4] depending on input
     """
+    anchors_wh = anchors[..., 2:] - anchors[..., :2]
+    ctr = anchors[..., :2] + 0.5 * anchors_wh
+    pred_ctr = deltas[..., :2] * anchors_wh + ctr
 
-    anchors_wh = anchors[:, 2:] - anchors[:, :2] # + 1
-    ctr = anchors[:, :2] + 0.5 * anchors_wh
-    pred_ctr = deltas[:, :2] * anchors_wh + ctr
-    pred_wh = torch.exp(deltas[:, 2:]) * anchors_wh
+    # Value for clamping large dw and dh predictions. The heuristic is that we clamp
+    # such that dw and dh are no larger than what would transform a 16px box into a
+    # 1000px box (based on a small anchor, 16px, and a typical image size, 1000px).
+    SCALE_CLAMP = 4.135 # ~= np.log(1000. / 16.)
+    deltas[..., 2:] = deltas[..., 2:].clamp(min=-SCALE_CLAMP, max=SCALE_CLAMP)
 
-    # TODO: make sure this +- 1 for centers aligns with Detectron implementation
-    # return torch.cat([pred_ctr - 0.5 * pred_wh, pred_ctr + 0.5 * pred_wh - 1], 1)
-    return torch.cat([pred_ctr - 0.5 * pred_wh, pred_ctr + 0.5 * pred_wh], 1)
+    pred_wh = deltas[..., 2:].exp() * anchors_wh
+    cat_dim = deltas.dim() - 1 # 1 if [N, 4] else [BS, N, 4]
+    return torch.cat([pred_ctr - 0.5 * pred_wh, pred_ctr + 0.5 * pred_wh], cat_dim)
 
 
 def box_area(box):
     """Args:
-    box (torch.Tensor): shape [N, 4] in 'ltrb' format
+    box (torch.Tensor): shape [N, 4] or [BS, N, 4] in 'ltrb' format
     """
-    return (box[:, 2] - box[:, 0]) * (box[:, 3] - box[:, 1])
+    return (box[..., 2] - box[..., 0]) * (box[..., 3] - box[..., 1])
 
 def clip_bboxes(bboxes, size):
     """Args:
         bboxes (torch.Tensor): in `ltrb` format. Shape [N, 4]
-        size (Union[torch.Size, tuple]): (H, W)"""
+        size (Union[torch.Size, tuple]): (H, W). Shape [2,]"""
     bboxes[:, 0::2] = bboxes[:, 0::2].clamp(0, size[1])
     bboxes[:, 1::2] = bboxes[:, 1::2].clamp(0, size[0])
     return bboxes
 
+def clip_bboxes_batch(bboxes, size):
+    # type: (Tensor, Tensor)->Tensor
+    """Args:
+        bboxes (torch.Tensor): in `ltrb` format. Shape [BS, N, 4]
+        size (torch.Tensor): (H, W). Shape [BS, 2] """
+    size = size.to(bboxes)
+    h_size = size[..., 0].view(-1, 1, 1) #.float()
+    w_size = size[..., 1].view(-1, 1, 1) #.float()
+    h_bboxes = bboxes[..., 1::2]
+    w_bboxes = bboxes[..., 0::2]
+    zeros = torch.zeros_like(h_bboxes)
+    bboxes[..., 1::2] = h_bboxes.where(h_bboxes > 0, zeros).where(h_bboxes < h_size, h_size)
+    bboxes[..., 0::2] = w_bboxes.where(w_bboxes > 0, zeros).where(w_bboxes < w_size, w_size)
+    # FIXME: I'm using where to support passing tensor. change to `clamp` when PR #32587 is resolved
+    # bboxes[:, 0::2] = bboxes[:, 0::2].clamp(0, size[1].item())
+    # bboxes[:, 1::2] = bboxes[:, 1::2].clamp(0, size[0].item())
+    return bboxes
+
 # implementation from https://github.com/kuangliu/torchcv/blob/master/torchcv/utils/box.py
 # with slight modifications
 def box_iou(boxes1, boxes2):
+    # type: (Tensor, Tensor)->Tensor
     """
     Return intersection-over-union (Jaccard index) of boxes.
     Both sets of boxes are expected to be in `ltrb`: (x1, y1, x2, y2) format.
@@ -120,7 +149,7 @@ def generate_anchors_boxes(
     wh = np.stack([np.ones(num_anchors) * ratio_vals_sq, np.ones(num_anchors) / ratio_vals_sq], axis=1) 
     lt = - 0.5 * wh * scale_vals
     rb = 0.5 * wh * scale_vals
-    base_offsets = torch.from_numpy(np.hstack([lt, rb])) # [num_anchors, 4]
+    base_offsets = torch.from_numpy(np.hstack([lt, rb])).float() # [num_anchors, 4]
     base_offsets = base_offsets.view(-1, 1, 1, 4) # [num_anchors, 1, 1, 4]
     # generate anchor boxes for all given strides
     all_anchors = []
@@ -162,8 +191,7 @@ def _generate_single_targets(gt_boxes):
         
         # Keep best box per anchor
         overlap, indices = overlap.max(1)
-        box_target = box2delta(gt_boxes[indices], anchors) # I've double checked that it's corrects
-        # TODO: add test that anchor + box target gives gt_bbox
+        box_target = box2delta(gt_boxes[indices], anchors)
         
         # There are three types of anchors. 
         # matched (with objects), unmatched (with background), and in between (which should be ignored)
@@ -195,7 +223,7 @@ def _generate_single_targets(gt_boxes):
     
 # copied from torchvision
 def batched_nms(boxes, scores, idxs, iou_threshold):
-    # type: (Tensor, Tensor, Tensor, float)
+    # type: (Tensor, Tensor, Tensor, float)->Tensor
     """
     Performs non-maximum suppression in a batched fashion.
     Each index value correspond to a category, and NMS
@@ -231,7 +259,21 @@ def batched_nms(boxes, scores, idxs, iou_threshold):
     keep = torch.ops.torchvision.nms(boxes_for_nms, scores, iou_threshold)
     return keep
 
-def decode(batch_cls_head, batch_box_head, anchors, img_shape=None, threshold=0.05, top_n=1000, iou_threshold=0.5):
+# jit actually makes it slower for fp16 and results are different!
+# FIXME: check it after 1.6 release. maybe they will fix JIT by that time
+# @torch.jit.script 
+def decode(
+    batch_cls_head,
+    batch_box_head,
+    anchors,
+    img_shapes=None,
+    img_scales=None,
+    threshold=0.05,
+    max_detection_points=5000,
+    max_detection_per_image=100,
+    iou_threshold=0.5,
+):
+    # type: (Tensor, Tensor, Tensor, Tensor, Tensor, float, int, int, float)->Tensor
     """
     Decodes raw outputs of a model for easy visualization of bboxes
     
@@ -239,48 +281,92 @@ def decode(batch_cls_head, batch_box_head, anchors, img_shape=None, threshold=0.
         batch_cls_head (torch.Tensor): shape [BS, *, NUM_CLASSES]
         batch_box_head (torch.Tensor): shape [BS, *, 4]
         anchors (torch.Tensor): shape [*, 4]
-        img_shape (Tuple[int]): if given clips predicted bboxes to img height and width
+        img_shapes (torch.Tensor): if given clips predicted bboxes to img height and width. Shape [BS, 2] or [2,]
+        img_scales (torch.Tensor): if given used to rescale img_shapes. Shape [BS,]
         threshold (float): minimum score threshold to consider object detected
-        top_n (int): maximum number of objects per image
+        max_detection_points (int): Maximum number of bboxes to consider for NMS for one image
+        max_detection_per_image (int): Maximum number of bboxes to return per image 
         iou_threshold (float): iou_threshold for Non Maximum Supression
         
     Returns:
-        out_bboxes (torch.Tensor): bboxes. Shape [BS, TOP_N] If img_shape is not given they are NOT CLIPPED (!)
-        out_scores (torch.Tensor): Probability scores for each bbox. Shape [BS, TOP_N]
-        out_classes (torch.Tensor): Predicted class for each bbox. Shape [BS, TOP_N]
+        torch.Tensor with bboxes, scores and classes
+            shape [BS, MAX_DETECTION_PER_IMAGE, 6]. 
+            bboxes in 'ltrb' format. If img_shape is not given they are NOT CLIPPED (!)
     """
     
     batch_size = batch_cls_head.size(0)
-    anchors = anchors.to(batch_cls_head)
-    out_scores = torch.zeros((batch_size, top_n)).to(batch_cls_head)
-    out_boxes = torch.zeros((batch_size, top_n, 4)).to(batch_cls_head)
-    out_classes = torch.zeros((batch_size, top_n)).to(batch_cls_head)
-    # it has to be raw logits but check anyway to avoid aplying sigmoid twice
+    num_classes = batch_cls_head.size(-1)
+
+    anchors = anchors.to(batch_cls_head).unsqueeze(0).expand(batch_size, -1, -1) # [N, 4] -> [BS, N, 4]
+    # it has to be raw logits but check anyway to avoid applying sigmoid twice
     if batch_cls_head.min() < 0 or batch_cls_head.max() > 1:
         batch_cls_head = batch_cls_head.sigmoid()
     
+    # It's much faster to calculate topk once for full batch here rather than doing it inside loop 
+    # In TF The same bbox may belong to two different objects
+    # select `max_detection_points` scores and corresponding bboxes
+    scores_topk_all, cls_topk_indices_all = torch.topk(batch_cls_head.view(batch_size, -1), k=max_detection_points)
+    indices_all = cls_topk_indices_all / num_classes
+    classes_all = cls_topk_indices_all % num_classes
+
+    # Gather corresponding bounding boxes & anchors, then regress and clip
+    box_topk_all = torch.gather(batch_box_head, 1, indices_all.unsqueeze(2).expand(-1, -1, 4))
+    anchors_topk_all = torch.gather(anchors, 1, indices_all.unsqueeze(2).expand(-1, -1, 4))
+    regressed_boxes_all = delta2box(box_topk_all, anchors_topk_all)
+    if img_shapes is not None:
+        if img_scales is not None:
+            img_shapes = img_shapes / img_scales.unsqueeze(1)
+        regressed_boxes_all = clip_bboxes_batch(regressed_boxes_all, img_shapes)
+
+    # prepare output tensors
+    out_scores = torch.zeros((batch_size, max_detection_per_image)).to(batch_cls_head)
+    out_boxes = torch.zeros((batch_size, max_detection_per_image, 4)).to(batch_cls_head)
+    out_classes = torch.zeros((batch_size, max_detection_per_image)).to(batch_cls_head)
+
     for batch in range(batch_size):
+        scores_topk = scores_topk_all[batch] #  , cls_topk_indices_all[batch]
+        classes = classes_all[batch] #cls_topk_indices % num_classes
+        box_topk = box_topk_all[batch] # torch.gather(batch_box_head[batch], 0, indices)
+        anchor_topk = anchors_topk_all[batch]
+        regressed_boxes = regressed_boxes_all[batch] # delta2box(box_topk, anchor_topk)
+
+        # apply NMS
+        nms_idx = batched_nms(regressed_boxes, scores_topk, classes, iou_threshold)
+        nms_idx = nms_idx[:min(len(nms_idx), max_detection_per_image)]
+        # select suppressed bboxes
+        im_scores = scores_topk[nms_idx]
+        im_classes = classes[nms_idx]
+        im_bboxes = regressed_boxes[nms_idx]
+        im_classes += 1  # back to class idx with background class = 0
+
+        out_scores[batch, :im_scores.size(0)] = im_scores
+        out_classes[batch, :im_classes.size(0)] = im_classes
+        out_boxes[batch, :im_bboxes.size(0)] = im_bboxes
+        # no need to pad because it's already padded with 0's
+        
+
+        ## old way ##
         # get regressed bboxes
-        all_img_bboxes = delta2box(batch_box_head[batch], anchors)
-        if img_shape: # maybe clip
-            all_img_bboxes = clip_bboxes(all_img_bboxes, img_shape)
+        # all_img_bboxes = delta2box(batch_box_head[batch], anchors)
+        # if img_shape: # maybe clip
+            # all_img_bboxes = clip_bboxes(all_img_bboxes, img_shape)
         # select at most `top_n` bboxes and from them select with score > threshold
-        max_cls_score, max_cls_idx = batch_cls_head[batch].max(1)
-        top_cls_score, top_cls_idx = max_cls_score.topk(top_n)
-        top_cls_idx = top_cls_idx[top_cls_score > threshold]
+        # max_cls_score, max_cls_idx = batch_cls_head[batch].max(1)
+        # top_cls_score, top_cls_idx = max_cls_score.topk(top_n)
+        # top_cls_idx = top_cls_idx[top_cls_score > threshold]
 
-        im_scores = max_cls_score[top_cls_idx]
-        im_classes = max_cls_idx[top_cls_idx]
-        im_bboxes = all_img_bboxes[top_cls_idx]
+        # im_scores = max_cls_score[top_cls_idx]
+        # im_classes = max_cls_idx[top_cls_idx]
+        # im_bboxes = all_img_bboxes[top_cls_idx]
         
         # apply NMS
-        nms_idx = batched_nms(im_bboxes, im_scores, im_classes, iou_threshold)
-        im_scores = im_scores[nms_idx]
-        im_classes = im_classes[nms_idx]
-        im_bboxes = im_bboxes[nms_idx]
+        # nms_idx = batched_nms(im_bboxes, im_scores, im_classes, iou_threshold)
+        # im_scores = im_scores[nms_idx]
+        # im_classes = im_classes[nms_idx]
+        # im_bboxes = im_bboxes[nms_idx]
         
-        out_scores[batch, :im_scores.size(0)] = im_scores
-        out_classes[batch, :im_classes.size(0)] = im_classes
-        out_boxes[batch, :im_bboxes.size(0)] = im_bboxes
+        # out_scores[batch, :im_scores.size(0)] = im_scores
+        # out_classes[batch, :im_classes.size(0)] = im_classes
+        # out_boxes[batch, :im_bboxes.size(0)] = im_bboxes
         
-    return out_boxes, out_scores, out_classes
\ No newline at end of file
+    return torch.cat([out_boxes, out_scores.unsqueeze(-1), out_classes.unsqueeze(-1)], dim=2)
\ No newline at end of file
diff --git a/tests/detection_models/test_det_models.py b/tests/detection_models/test_det_models.py
index 23715a2..62ebb13 100644
--- a/tests/detection_models/test_det_models.py
+++ b/tests/detection_models/test_det_models.py
@@ -11,14 +11,14 @@
 
 # all weights were tested on 05.2020. for now only leave one model for faster tests
 MODEL_NAMES = [
-    "efficientdet_b0",
+    "efficientdet_d0",
     "retinanet_r50_fpn",
-    # "efficientdet_b1",
-    # "efficientdet_b2",
-    # "efficientdet_b3",
-    # "efficientdet_b4",
-    # "efficientdet_b5",
-    # "efficientdet_b6",
+    # "efficientdet_d1",
+    # "efficientdet_d2",
+    # "efficientdet_d3",
+    # "efficientdet_d4",
+    # "efficientdet_d5",
+    # "efficientdet_d6",
     # "retinanet_r101_fpn",
 ]
 
@@ -50,10 +50,10 @@ def test_coco_pretrain(arch):
     for im_cls, im in IMGS.items():
         im = np.array(im.resize((inp_size, inp_size)))
         im_t = tensor_from_rgb_image(preprocess_fn(im)).unsqueeze(0).float().cuda()
-        boxes, scores, classes = m.predict(im_t)
+        boxes_scores_classes = m.predict(im_t)
         # check that most confident bbox is close to correct class. The reason for such strange test is 
         # because in different models class mappings are shifted by +- 1
-        assert (classes[0, 0] - im_cls) < 2
+        assert (boxes_scores_classes[0, 0, 5] - im_cls) < 2
 
 
 @pytest.mark.parametrize("arch", MODEL_NAMES[:2])
diff --git a/tests/utils/test_utils.py b/tests/utils/test_utils.py
new file mode 100644
index 0000000..13b4f23
--- /dev/null
+++ b/tests/utils/test_utils.py
@@ -0,0 +1,125 @@
+import torch
+import pytest
+import pytorch_tools as pt
+
+def random_boxes(mean_box, stdev, N):
+    return torch.rand(N, 4) * stdev + torch.tensor(mean_box, dtype=torch.float)
+
+DEVICE_DTYPE =  [
+    ("cpu", torch.float), 
+    ("cuda", torch.float), 
+    ("cuda", torch.half)
+]
+# check that it works for all combinations of dtype and device
+@pytest.mark.parametrize("device_dtype", DEVICE_DTYPE)
+def test_clip_bboxes(device_dtype):
+    device, dtype = device_dtype
+    bboxes = torch.tensor(
+        [
+            [-5, -10, 50, 100],
+            [10, 15, 20, 25],
+        ],
+        device=device,
+        dtype=dtype,
+    )
+    expected_bboxes = torch.tensor(
+        [
+            [0, 0, 40, 60],
+            [10, 15, 20, 25],
+        ],
+        device=device,
+        dtype=dtype,
+    )
+    size = (60, 40)
+    # test single bbox clip
+    res1 = pt.utils.box.clip_bboxes(bboxes, size)
+    assert torch.allclose(res1, expected_bboxes)
+    # test single bbox clip passing torch.Size
+    res2 = pt.utils.box.clip_bboxes(bboxes, torch.Size(size))
+    assert torch.allclose(res2, expected_bboxes)
+
+    BS = 4
+    batch_bboxes = bboxes.unsqueeze(0).expand(BS, -1, -1)
+    batch_expected = expected_bboxes.unsqueeze(0).expand(BS, -1, -1)
+    batch_sizes = torch.tensor(size).repeat(BS, 1)
+    # test batch clipping
+    res3 = pt.utils.box.clip_bboxes_batch(batch_bboxes.clone(), batch_sizes)
+    assert torch.allclose(res3, batch_expected)
+
+    # check that even in batch mode we can pass single size
+    res4 = pt.utils.box.clip_bboxes_batch(batch_bboxes.clone(), torch.tensor(size))
+    assert torch.allclose(res4, batch_expected)
+
+    jit_clip = torch.jit.script(pt.utils.box.clip_bboxes_batch)
+    # check that function is JIT script friendly
+    res5 = jit_clip(batch_bboxes.clone(), batch_sizes)
+    assert torch.allclose(res5, batch_expected)
+
+@pytest.mark.parametrize("device_dtype", DEVICE_DTYPE)
+def test_delta2box(device_dtype):
+    device, dtype = device_dtype
+    anchors = torch.tensor(
+        [
+            [ 0.,  0.,  1.,  1.],
+            [ 0.,  0.,  1.,  1.],
+            [ 0.,  0.,  1.,  1.],
+            [ 5.,  5.,  5.,  5.]
+        ],
+        device=device,
+        dtype=dtype,
+    )
+    deltas = torch.tensor(
+        [
+            [  0.,   0.,   0.,   0.],
+            [  1.,   1.,   1.,   1.],
+            [  0.,   0.,   2.,  -1.],
+            [ 0.7, -1.9, -0.5,  0.3]
+        ],
+        device=device,
+        dtype=dtype,
+    )
+    # by default we don't expect results to be clipped
+    expected_res = torch.tensor(
+        [
+            [0.0000, 0.0000, 1.0000, 1.0000],
+            [0.1409, 0.1409, 2.8591, 2.8591],
+            [-3.1945, 0.3161, 4.1945, 0.6839],
+            [5.0000, 5.0000, 5.0000, 5.0000]
+        ],
+        device=device,
+        dtype=dtype,
+    )
+    res1 =  pt.utils.box.delta2box(deltas, anchors)
+    assert torch.allclose(res1, expected_res, atol=3e-4)
+
+    BS = 4
+    batch_anchors = anchors.unsqueeze(0).expand(BS, -1, -1)
+    batch_deltas = deltas.unsqueeze(0).expand(BS, -1, -1)
+    batch_expected = expected_res.unsqueeze(0).expand(BS, -1, -1)
+
+    # test applying to batch 
+    res2 =  pt.utils.box.delta2box(batch_deltas.clone(), batch_anchors)
+    assert torch.allclose(res2, batch_expected, atol=3e-4)
+
+    # check that function is JIT script friendly
+    jit_func = torch.jit.script(pt.utils.box.delta2box)
+    res3 = jit_func(batch_deltas.clone(), batch_anchors)
+    assert torch.allclose(res3, batch_expected, atol=3e-4)
+
+@pytest.mark.parametrize("device_dtype", DEVICE_DTYPE)
+def test_box2delta(device_dtype):
+    ## this test only checks that encoding and decoding  gives the same result
+    device, dtype = device_dtype
+    boxes = random_boxes([10, 10, 20, 20], 10, 10).to(device).to(dtype)
+    anchors = random_boxes([10, 10, 20, 20], 10, 10).to(device).to(dtype)
+    deltas = pt.utils.box.box2delta(boxes, anchors)
+    boxes_reconstructed = pt.utils.box.delta2box(deltas, anchors)
+    atol = 2e-2 if dtype == torch.half else 1e-6 # for fp16 sometimes error is large 
+    assert torch.allclose(boxes, boxes_reconstructed, atol=atol) 
+
+    # check that it's jit friendly
+    jit_box2delta = torch.jit.script(pt.utils.box.box2delta)
+    jit_delta2box = torch.jit.script(pt.utils.box.delta2box)
+    deltas2 = jit_box2delta(boxes, anchors)
+    boxes_reconstructed2 = jit_delta2box(deltas2, anchors)
+    assert torch.allclose(boxes, boxes_reconstructed2,  atol=atol)
\ No newline at end of file

From 56e00473da880664f98b9c6aa4208adced667914 Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Thu, 4 Jun 2020 11:40:15 +0300
Subject: [PATCH 51/54] make same ops scriptable

---
 pytorch_tools/modules/tf_same_ops.py | 41 +++++++++++++++++++---------
 1 file changed, 28 insertions(+), 13 deletions(-)

diff --git a/pytorch_tools/modules/tf_same_ops.py b/pytorch_tools/modules/tf_same_ops.py
index 2ce7e0f..1c5adb6 100644
--- a/pytorch_tools/modules/tf_same_ops.py
+++ b/pytorch_tools/modules/tf_same_ops.py
@@ -3,30 +3,45 @@
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
+from torch.nn.modules.utils import _pair
 
+def pad_same(x, k, s, d, value=0):
+    # type: (Tensor, int, int, int, float)->Tensor
+    # x - input tensor, s - stride, k - kernel_size, d - dilation
+    ih, iw = x.size()[-2:]
+    pad_h = max((math.ceil(ih / s) - 1) * s + (k - 1) * d + 1 - ih, 0)
+    pad_w = max((math.ceil(iw / s) - 1) * s + (k - 1) * d + 1 - iw, 0)
+    if pad_h > 0 or pad_w > 0:
+        x = F.pad(x, [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2], value=value)
+    return x
+
+# current implementation is only for symmetric case. But there are no non symmetric cases 
+def conv2d_same(x, weight, bias=None, stride=(1, 1), dilation=(1, 1), groups=1):
+    # type: (Tensor, Tensor, Optional[torch.Tensor], Tuple[int, int], Tuple[int, int], int)->Tensor
+    x = pad_same(x, weight.shape[-1], stride[0], dilation[0])
+    return F.conv2d(x, weight, bias, stride, (0, 0), dilation, groups)
+
+def maxpool2d_same(x, kernel_size, stride):
+    # type: (Tensor, Tuple[int, int], Tuple[int, int])->Tensor
+    x = pad_same(x, kernel_size[0], stride[0], 1, value=-float('inf'))
+    return F.max_pool2d(x, kernel_size, stride, (0, 0))
 
 class Conv2dSamePadding(nn.Conv2d):
     """Assymetric padding matching TensorFlow `same`"""
 
     def forward(self, x):
-        h, w = x.shape[-2:]
-        pad_w = (math.ceil(w / self.stride[1]) - 1) * self.stride[1] - w + self.kernel_size[1]
-        pad_h = (math.ceil(h / self.stride[0]) - 1) * self.stride[0] - h + self.kernel_size[0]
-        if pad_w > 0 or pad_h > 0:
-            x = F.pad(x, [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2])
-        return super().forward(x)
-
+        return conv2d_same(x, self.weight, self.bias, self.stride, self.dilation, self.groups)
 
+# as of 1.5 there is no _pair in MaxPool. Remove when this is fixed 
 class MaxPool2dSamePadding(nn.MaxPool2d):
     """Assymetric padding matching TensorFlow `same`"""
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.kernel_size = _pair(self.kernel_size)
+        self.stride = _pair(self.stride)
 
     def forward(self, x):
-        h, w = x.shape[-2:]
-        pad_w = (math.ceil(w / self.stride) - 1) * self.stride - w + self.kernel_size
-        pad_h = (math.ceil(h / self.stride) - 1) * self.stride - h + self.kernel_size
-        if pad_w > 0 or pad_h > 0:
-            x = F.pad(x, [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2], value=-float("inf"))
-        return super().forward(x)
+        return maxpool2d_same(x, self.kernel_size, self.stride)
 
 
 def conv_to_same_conv(module):

From e2d35d8afb9845ec5b468b0b7e2cf30a8cc5d72e Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Thu, 4 Jun 2020 11:47:42 +0300
Subject: [PATCH 52/54] fully matching EffDet

---
 pytorch_tools/detection_models/efficientdet.py | 14 +++++++++-----
 pytorch_tools/detection_models/retinanet.py    |  3 +--
 pytorch_tools/utils/box.py                     |  2 +-
 3 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/pytorch_tools/detection_models/efficientdet.py b/pytorch_tools/detection_models/efficientdet.py
index 5b3c299..e765f97 100644
--- a/pytorch_tools/detection_models/efficientdet.py
+++ b/pytorch_tools/detection_models/efficientdet.py
@@ -104,6 +104,7 @@ def make_head_norm():
         self.box_head_convs = make_head(4 * anchors_per_location)
         self.box_head_norms = make_head_norm()
         self.num_classes = num_classes
+        self.num_head_repeats = num_head_repeats
 
         patch_bn(self)
         self._initialize_weights()
@@ -132,6 +133,8 @@ def forward(self, x):
         box_outputs = []
         for feat, (cls_bns, box_bns) in zip(features, zip(self.cls_head_norms, self.box_head_norms)):
             cls_feat, box_feat = feat, feat
+            # it looks like that with drop_connect there is an additional residual here
+            # TODO: need to investigate using pretrained weights
             for cls_conv, cls_bn in zip(self.cls_head_convs, cls_bns):
                 cls_feat = cls_bn(cls_conv(cls_feat))
             for box_conv, box_bn in zip(self.box_head_convs, box_bns):
@@ -148,18 +151,19 @@ def forward(self, x):
         # my anchors are in [x1, y1, x2,y2] format while pretrained weights are in [y1, x1, y2, x2] format
         # it may be confusing to reorder x and y every time later so I do it once here. it gives
         # compatability with pretrained weigths from Google and doesn't affect training from scratch
-        box_outputs = box_outputs[..., [1, 0, 3, 2]]
+        # box_outputs = box_outputs[..., [1, 0, 3, 2]]  # TODO: return back
         return class_outputs, box_outputs
 
     @torch.no_grad()
     def predict(self, x):
-        """Run forward on given images and decode raw prediction into bboxes"""
+        """Run forward on given images and decode raw prediction into bboxes
+        Returns: bboxes, scores, classes
+        """
         class_outputs, box_outputs = self.forward(x)
         anchors = box_utils.generate_anchors_boxes(x.shape[-2:])[0]
-        out_bboxes, out_scores, out_classes = box_utils.decode(
-            class_outputs, box_outputs, anchors, img_shape=x.shape[-2:]
+        return box_utils.decode(
+            class_outputs, box_outputs, anchors, #img_shape=x.shape[-2:]
         )
-        return out_bboxes, out_scores, out_classes
 
     def _initialize_weights(self):
         # init everything except encoder
diff --git a/pytorch_tools/detection_models/retinanet.py b/pytorch_tools/detection_models/retinanet.py
index 1ca1078..0ddf559 100644
--- a/pytorch_tools/detection_models/retinanet.py
+++ b/pytorch_tools/detection_models/retinanet.py
@@ -126,10 +126,9 @@ def predict(self, x):
         """Run forward on given images and decode raw prediction into bboxes"""
         class_outputs, box_outputs = self.forward(x)
         anchors = box_utils.generate_anchors_boxes(x.shape[-2:])[0]
-        out_bboxes, out_scores, out_classes = box_utils.decode(
+        return box_utils.decode(
             class_outputs, box_outputs, anchors, img_shape=x.shape[-2:]
         )
-        return out_bboxes, out_scores, out_classes
 
     def _initialize_weights(self):
         # init everything except encoder
diff --git a/pytorch_tools/utils/box.py b/pytorch_tools/utils/box.py
index f48a86d..5b73c93 100644
--- a/pytorch_tools/utils/box.py
+++ b/pytorch_tools/utils/box.py
@@ -1,4 +1,4 @@
-"""Various functions to help with bboxes"""
+"""Various functions to help with bboxes for object detection"""
 import torch
 import numpy as np
 from functools import wraps

From 19a2385e893a977dca949dcd45cdc5285922c6cc Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Thu, 4 Jun 2020 11:52:23 +0300
Subject: [PATCH 53/54] simplify cat

---
 pytorch_tools/utils/box.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/pytorch_tools/utils/box.py b/pytorch_tools/utils/box.py
index 5b73c93..73bb377 100644
--- a/pytorch_tools/utils/box.py
+++ b/pytorch_tools/utils/box.py
@@ -20,8 +20,7 @@ def box2delta(boxes, anchors):
     boxes_ctr = boxes[..., :2] + 0.5 * boxes_wh
     offset_delta = (boxes_ctr - anchors_ctr) / anchors_wh
     scale_delta = torch.log(boxes_wh / anchors_wh)
-    cat_dim = boxes.dim() - 1 # 1 if [N, 4] else [BS, N, 4]
-    return torch.cat([offset_delta, scale_delta], cat_dim)
+    return torch.cat([offset_delta, scale_delta], -1)
 
 
 def delta2box(deltas, anchors):
@@ -45,8 +44,7 @@ def delta2box(deltas, anchors):
     deltas[..., 2:] = deltas[..., 2:].clamp(min=-SCALE_CLAMP, max=SCALE_CLAMP)
 
     pred_wh = deltas[..., 2:].exp() * anchors_wh
-    cat_dim = deltas.dim() - 1 # 1 if [N, 4] else [BS, N, 4]
-    return torch.cat([pred_ctr - 0.5 * pred_wh, pred_ctr + 0.5 * pred_wh], cat_dim)
+    return torch.cat([pred_ctr - 0.5 * pred_wh, pred_ctr + 0.5 * pred_wh], -1)
 
 
 def box_area(box):

From 0568102788f8bd67a3ea54f450e8589b7bbebf6a Mon Sep 17 00:00:00 2001
From: zakajd <djamilzak@gmail.com>
Date: Thu, 4 Jun 2020 20:17:57 +0300
Subject: [PATCH 54/54] formatting

---
 .../detection_models/efficientdet.py          |   8 +-
 pytorch_tools/detection_models/retinanet.py   |  13 +-
 pytorch_tools/models/__init__.py              |   2 +-
 pytorch_tools/models/bit_resnet.py            | 455 +++++++++---------
 pytorch_tools/models/efficientnet.py          |  11 +-
 pytorch_tools/models/hrnet.py                 | 136 +++---
 pytorch_tools/models/resnet.py                |   7 +-
 pytorch_tools/models/tresnet.py               |  37 +-
 pytorch_tools/models/vgg.py                   |   1 -
 pytorch_tools/modules/activated_batch_norm.py |   2 +-
 pytorch_tools/modules/tf_same_ops.py          |  12 +-
 pytorch_tools/utils/box.py                    | 117 ++---
 pytorch_tools/utils/misc.py                   |   9 +-
 tests/detection_models/test_det_models.py     |   3 +-
 tests/losses/test_losses.py                   |  11 +-
 tests/models/test_models.py                   |  21 +-
 tests/models/test_weights.py                  |   2 +
 tests/modules/test_modules.py                 |   2 +
 tests/segmentation_models/test_segm_models.py |  11 +-
 tests/utils/test_utils.py                     |  24 +-
 20 files changed, 473 insertions(+), 411 deletions(-)

diff --git a/pytorch_tools/detection_models/efficientdet.py b/pytorch_tools/detection_models/efficientdet.py
index e765f97..0446b56 100644
--- a/pytorch_tools/detection_models/efficientdet.py
+++ b/pytorch_tools/detection_models/efficientdet.py
@@ -161,16 +161,14 @@ def predict(self, x):
         """
         class_outputs, box_outputs = self.forward(x)
         anchors = box_utils.generate_anchors_boxes(x.shape[-2:])[0]
-        return box_utils.decode(
-            class_outputs, box_outputs, anchors, #img_shape=x.shape[-2:]
-        )
+        return box_utils.decode(class_outputs, box_outputs, anchors)
 
     def _initialize_weights(self):
         # init everything except encoder
         no_encoder_m = [m for n, m in self.named_modules() if not "encoder" in n]
         initialize_iterator(no_encoder_m)
-        # need to init last bias so that after sigmoid it's 0.01 
-        cls_bias_init = -torch.log(torch.tensor((1 - 0.01) / 0.01)) # -4.59
+        # need to init last bias so that after sigmoid it's 0.01
+        cls_bias_init = -torch.log(torch.tensor((1 - 0.01) / 0.01))  # -4.59
         nn.init.constant_(self.cls_head_convs[-1][1].bias, cls_bias_init)
 
 
diff --git a/pytorch_tools/detection_models/retinanet.py b/pytorch_tools/detection_models/retinanet.py
index 0ddf559..2fbdf74 100644
--- a/pytorch_tools/detection_models/retinanet.py
+++ b/pytorch_tools/detection_models/retinanet.py
@@ -44,7 +44,7 @@ class RetinaNet(nn.Module):
 
     def __init__(
         self,
-        pretrained="coco", # not used here for proper signature
+        pretrained="coco",  # not used here for proper signature
         encoder_name="resnet50",
         encoder_weights="imagenet",
         pyramid_channels=256,
@@ -90,7 +90,7 @@ def make_final_convs():
         self.box_convs = make_final_convs()
         self.box_head_conv = conv3x3(pyramid_channels, 4 * anchors_per_location, bias=True)
         self.num_classes = num_classes
-        self. _initialize_weights()
+        self._initialize_weights()
 
     # Name from mmdetectin for convenience
     def extract_features(self, x):
@@ -126,18 +126,17 @@ def predict(self, x):
         """Run forward on given images and decode raw prediction into bboxes"""
         class_outputs, box_outputs = self.forward(x)
         anchors = box_utils.generate_anchors_boxes(x.shape[-2:])[0]
-        return box_utils.decode(
-            class_outputs, box_outputs, anchors, img_shape=x.shape[-2:]
-        )
+        return box_utils.decode(class_outputs, box_outputs, anchors)
 
     def _initialize_weights(self):
         # init everything except encoder
         no_encoder_m = [m for n, m in self.named_modules() if not "encoder" in n]
         initialize_iterator(no_encoder_m)
-        # need to init last bias so that after sigmoid it's 0.01 
-        cls_bias_init = -torch.log(torch.tensor((1 - 0.01) / 0.01)) # -4.59
+        # need to init last bias so that after sigmoid it's 0.01
+        cls_bias_init = -torch.log(torch.tensor((1 - 0.01) / 0.01))  # -4.59
         nn.init.constant_(self.cls_head_conv.bias, cls_bias_init)
 
+
 # Don't really know input size for the models. 512 is just a guess
 PRETRAIN_SETTINGS = {**DEFAULT_IMAGENET_SETTINGS, "input_size": (512, 512), "crop_pct": 1, "num_classes": 80}
 
diff --git a/pytorch_tools/models/__init__.py b/pytorch_tools/models/__init__.py
index ef9c0d4..4fb855e 100644
--- a/pytorch_tools/models/__init__.py
+++ b/pytorch_tools/models/__init__.py
@@ -51,4 +51,4 @@
 from .bit_resnet import bit_m_101x1
 from .bit_resnet import bit_m_101x3
 from .bit_resnet import bit_m_152x2
-from .bit_resnet import bit_m_152x4
\ No newline at end of file
+from .bit_resnet import bit_m_152x4
diff --git a/pytorch_tools/models/bit_resnet.py b/pytorch_tools/models/bit_resnet.py
index 3108e97..c5acbd5 100644
--- a/pytorch_tools/models/bit_resnet.py
+++ b/pytorch_tools/models/bit_resnet.py
@@ -4,7 +4,7 @@
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
-#      http://www.apache.org/licenses/LICENSE-2.0
+#            http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
@@ -29,179 +29,181 @@
 
 
 def conv3x3(cin, cout, stride=1, groups=1, bias=False):
-  return StdConv2d(cin, cout, kernel_size=3, stride=stride,
-                   padding=1, bias=bias, groups=groups)
+    return StdConv2d(cin, cout, kernel_size=3, stride=stride, padding=1, bias=bias, groups=groups)
 
 
 def conv1x1(cin, cout, stride=1, bias=False):
-  return StdConv2d(cin, cout, kernel_size=1, stride=stride,
-                   padding=0, bias=bias)
+    return StdConv2d(cin, cout, kernel_size=1, stride=stride, padding=0, bias=bias)
 
 
 def tf2th(conv_weights):
-  """Possibly convert HWIO to OIHW."""
-  if conv_weights.ndim == 4:
-    conv_weights = conv_weights.transpose([3, 2, 0, 1])
-  return torch.from_numpy(conv_weights)
+    """Possibly convert HWIO to OIHW."""
+    if conv_weights.ndim == 4:
+        conv_weights = conv_weights.transpose([3, 2, 0, 1])
+    return torch.from_numpy(conv_weights)
 
 
 class PreActBottleneck(nn.Module):
-  """Pre-activation (v2) bottleneck block.
-
-  Follows the implementation of "Identity Mappings in Deep Residual Networks":
-  https://github.com/KaimingHe/resnet-1k-layers/blob/master/resnet-pre-act.lua
-
-  Except it puts the stride on 3x3 conv when available.
-  """
-
-  def __init__(self, cin, cout=None, cmid=None, stride=1):
-    super().__init__()
-    cout = cout or cin
-    cmid = cmid or cout//4
-
-    self.gn1 = nn.GroupNorm(32, cin)
-    self.conv1 = conv1x1(cin, cmid)
-    self.gn2 = nn.GroupNorm(32, cmid)
-    self.conv2 = conv3x3(cmid, cmid, stride)  # Original code has it on conv1!!
-    self.gn3 = nn.GroupNorm(32, cmid)
-    self.conv3 = conv1x1(cmid, cout)
-    self.relu = nn.ReLU(inplace=True)
-
-    if (stride != 1 or cin != cout):
-      # Projection also with pre-activation according to paper.
-      self.downsample = conv1x1(cin, cout, stride)
-
-  def forward(self, x):
-    out = self.relu(self.gn1(x))
-
-    # Residual branch
-    residual = x
-    if hasattr(self, 'downsample'):
-      residual = self.downsample(out)
-
-    # Unit's branch
-    out = self.conv1(out)
-    out = self.conv2(self.relu(self.gn2(out)))
-    out = self.conv3(self.relu(self.gn3(out)))
-
-    return out + residual
-
-  def load_from(self, weights, prefix=''):
-    convname = 'standardized_conv2d'
-    with torch.no_grad():
-      self.conv1.weight.copy_(tf2th(weights[f'{prefix}a/{convname}/kernel']))
-      self.conv2.weight.copy_(tf2th(weights[f'{prefix}b/{convname}/kernel']))
-      self.conv3.weight.copy_(tf2th(weights[f'{prefix}c/{convname}/kernel']))
-      self.gn1.weight.copy_(tf2th(weights[f'{prefix}a/group_norm/gamma']))
-      self.gn2.weight.copy_(tf2th(weights[f'{prefix}b/group_norm/gamma']))
-      self.gn3.weight.copy_(tf2th(weights[f'{prefix}c/group_norm/gamma']))
-      self.gn1.bias.copy_(tf2th(weights[f'{prefix}a/group_norm/beta']))
-      self.gn2.bias.copy_(tf2th(weights[f'{prefix}b/group_norm/beta']))
-      self.gn3.bias.copy_(tf2th(weights[f'{prefix}c/group_norm/beta']))
-      if hasattr(self, 'downsample'):
-        w = weights[f'{prefix}a/proj/{convname}/kernel']
-        self.downsample.weight.copy_(tf2th(w))
+    """Pre-activation (v2) bottleneck block.
+
+    Follows the implementation of "Identity Mappings in Deep Residual Networks":
+    https://github.com/KaimingHe/resnet-1k-layers/blob/master/resnet-pre-act.lua
+
+    Except it puts the stride on 3x3 conv when available.
+    """
+
+    def __init__(self, cin, cout=None, cmid=None, stride=1):
+        super().__init__()
+        cout = cout or cin
+        cmid = cmid or cout // 4
+
+        self.gn1 = nn.GroupNorm(32, cin)
+        self.conv1 = conv1x1(cin, cmid)
+        self.gn2 = nn.GroupNorm(32, cmid)
+        self.conv2 = conv3x3(cmid, cmid, stride)  # Original code has it on conv1!!
+        self.gn3 = nn.GroupNorm(32, cmid)
+        self.conv3 = conv1x1(cmid, cout)
+        self.relu = nn.ReLU(inplace=True)
+
+        if stride != 1 or cin != cout:
+            # Projection also with pre-activation according to paper.
+            self.downsample = conv1x1(cin, cout, stride)
+
+    def forward(self, x):
+        out = self.relu(self.gn1(x))
+
+        # Residual branch
+        residual = x
+        if hasattr(self, "downsample"):
+            residual = self.downsample(out)
+
+        # Unit's branch
+        out = self.conv1(out)
+        out = self.conv2(self.relu(self.gn2(out)))
+        out = self.conv3(self.relu(self.gn3(out)))
+
+        return out + residual
+
+    def load_from(self, weights, prefix=""):
+        convname = "standardized_conv2d"
+        with torch.no_grad():
+            self.conv1.weight.copy_(tf2th(weights[f"{prefix}a/{convname}/kernel"]))
+            self.conv2.weight.copy_(tf2th(weights[f"{prefix}b/{convname}/kernel"]))
+            self.conv3.weight.copy_(tf2th(weights[f"{prefix}c/{convname}/kernel"]))
+            self.gn1.weight.copy_(tf2th(weights[f"{prefix}a/group_norm/gamma"]))
+            self.gn2.weight.copy_(tf2th(weights[f"{prefix}b/group_norm/gamma"]))
+            self.gn3.weight.copy_(tf2th(weights[f"{prefix}c/group_norm/gamma"]))
+            self.gn1.bias.copy_(tf2th(weights[f"{prefix}a/group_norm/beta"]))
+            self.gn2.bias.copy_(tf2th(weights[f"{prefix}b/group_norm/beta"]))
+            self.gn3.bias.copy_(tf2th(weights[f"{prefix}c/group_norm/beta"]))
+            if hasattr(self, "downsample"):
+                w = weights[f"{prefix}a/proj/{convname}/kernel"]
+                self.downsample.weight.copy_(tf2th(w))
+
 
 # this models are designed for trasfer learning only! not for training from scratch
 class ResNetV2(nn.Module):
-  """
-  Implementation of Pre-activation (v2) ResNet mode.
-  Used to create Bit-M-50/101/152x1/2/3/4 models
-  
-  Args:
-    num_classes (int): Number of classification classes. Defaults to 5
-  """
-
-  def __init__(
-    self,
-    block_units,
-    width_factor,
-    # in_channels=3, # TODO: add later
-    num_classes=5, # just a random number
-    # encoder=False, # TODO: add later
+    """
+    Implementation of Pre-activation (v2) ResNet mode.
+    Used to create Bit-M-50/101/152x1/2/3/4 models
+    
+    Args:
+        num_classes (int): Number of classification classes. Defaults to 5
+    """
+
+    def __init__(
+        self,
+        block_units,
+        width_factor,
+        # in_channels=3, # TODO: add later
+        num_classes=5,  # just a random number
+        # encoder=False, # TODO: add later
     ):
-    super().__init__()
-    wf = width_factor  # shortcut 'cause we'll use it a lot.
-
-    # The following will be unreadable if we split lines.
-    # pylint: disable=line-too-long
-    self.root = nn.Sequential(OrderedDict([
-        ('conv', StdConv2d(3, 64*wf, kernel_size=7, stride=2, padding=3, bias=False)),
-        ('pad', nn.ConstantPad2d(1, 0)),
-        ('pool', nn.MaxPool2d(kernel_size=3, stride=2, padding=0)),
-        # The following is subtly not the same!
-        # ('pool', nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),
-    ]))
-
-    self.body = nn.Sequential(OrderedDict([
-        ('block1', nn.Sequential(OrderedDict(
-            [('unit01', PreActBottleneck(cin=64*wf, cout=256*wf, cmid=64*wf))] +
-            [(f'unit{i:02d}', PreActBottleneck(cin=256*wf, cout=256*wf, cmid=64*wf)) for i in range(2, block_units[0] + 1)],
-        ))),
-        ('block2', nn.Sequential(OrderedDict(
-            [('unit01', PreActBottleneck(cin=256*wf, cout=512*wf, cmid=128*wf, stride=2))] +
-            [(f'unit{i:02d}', PreActBottleneck(cin=512*wf, cout=512*wf, cmid=128*wf)) for i in range(2, block_units[1] + 1)],
-        ))),
-        ('block3', nn.Sequential(OrderedDict(
-            [('unit01', PreActBottleneck(cin=512*wf, cout=1024*wf, cmid=256*wf, stride=2))] +
-            [(f'unit{i:02d}', PreActBottleneck(cin=1024*wf, cout=1024*wf, cmid=256*wf)) for i in range(2, block_units[2] + 1)],
-        ))),
-        ('block4', nn.Sequential(OrderedDict(
-            [('unit01', PreActBottleneck(cin=1024*wf, cout=2048*wf, cmid=512*wf, stride=2))] +
-            [(f'unit{i:02d}', PreActBottleneck(cin=2048*wf, cout=2048*wf, cmid=512*wf)) for i in range(2, block_units[3] + 1)],
-        ))),
-    ]))
-    # pylint: enable=line-too-long
-
-    self.head = nn.Sequential(OrderedDict([
-        ('gn', nn.GroupNorm(32, 2048*wf)),
-        ('relu', nn.ReLU(inplace=True)),
-        ('avg', nn.AdaptiveAvgPool2d(output_size=1)),
-        ('conv', nn.Conv2d(2048*wf, num_classes, kernel_size=1, bias=True)),
-    ]))
-
-  def features(self, x):
-    return self.body(self.root(x))
-
-  def logits(self, x):
-    return self.head(x)
-
-  def forward(self, x):
-    x = self.logits(self.features(x))
-    assert x.shape[-2:] == (1, 1)  # We should have no spatial shape left.
-    return x[...,0,0]
-
-  def load_from(self, weights, prefix='resnet/'):
-    with torch.no_grad():
-      self.root.conv.weight.copy_(tf2th(weights[f'{prefix}root_block/standardized_conv2d/kernel']))  # pylint: disable=line-too-long
-      self.head.gn.weight.copy_(tf2th(weights[f'{prefix}group_norm/gamma']))
-      self.head.gn.bias.copy_(tf2th(weights[f'{prefix}group_norm/beta']))
-      # always zero_head
-      nn.init.zeros_(self.head.conv.weight)
-      nn.init.zeros_(self.head.conv.bias)
-
-      for bname, block in self.body.named_children():
-        for uname, unit in block.named_children():
-          unit.load_from(weights, prefix=f'{prefix}{bname}/{uname}/')
-
-
-
-
-KNOWN_MODELS = OrderedDict([
-    ('BiT-M-R50x1', lambda *a, **kw: ResNetV2([3, 4, 6, 3], 1, *a, **kw)),
-    ('BiT-M-R50x3', lambda *a, **kw: ResNetV2([3, 4, 6, 3], 3, *a, **kw)),
-    ('BiT-M-R101x1', lambda *a, **kw: ResNetV2([3, 4, 23, 3], 1, *a, **kw)),
-    ('BiT-M-R101x3', lambda *a, **kw: ResNetV2([3, 4, 23, 3], 3, *a, **kw)),
-    ('BiT-M-R152x2', lambda *a, **kw: ResNetV2([3, 8, 36, 3], 2, *a, **kw)),
-    ('BiT-M-R152x4', lambda *a, **kw: ResNetV2([3, 8, 36, 3], 4, *a, **kw)),
-
-    ('BiT-S-R50x1', lambda *a, **kw: ResNetV2([3, 4, 6, 3], 1, *a, **kw)),
-    ('BiT-S-R50x3', lambda *a, **kw: ResNetV2([3, 4, 6, 3], 3, *a, **kw)),
-    ('BiT-S-R101x1', lambda *a, **kw: ResNetV2([3, 4, 23, 3], 1, *a, **kw)),
-    ('BiT-S-R101x3', lambda *a, **kw: ResNetV2([3, 4, 23, 3], 3, *a, **kw)),
-    ('BiT-S-R152x2', lambda *a, **kw: ResNetV2([3, 8, 36, 3], 2, *a, **kw)),
-    ('BiT-S-R152x4', lambda *a, **kw: ResNetV2([3, 8, 36, 3], 4, *a, **kw)),
-])
+        super().__init__()
+        wf = width_factor  # shortcut 'cause we'll use it a lot.
+
+        # The following will be unreadable if we split lines.
+        # pylint: disable=line-too-long
+        # fmt: off
+        self.root = nn.Sequential(OrderedDict([
+                ('conv', StdConv2d(3, 64*wf, kernel_size=7, stride=2, padding=3, bias=False)),
+                ('pad', nn.ConstantPad2d(1, 0)),
+                ('pool', nn.MaxPool2d(kernel_size=3, stride=2, padding=0)),
+                # The following is subtly not the same!
+                # ('pool', nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),
+        ]))
+
+        self.body = nn.Sequential(OrderedDict([
+                ('block1', nn.Sequential(OrderedDict(
+                        [('unit01', PreActBottleneck(cin=64*wf, cout=256*wf, cmid=64*wf))] +
+                        [(f'unit{i:02d}', PreActBottleneck(cin=256*wf, cout=256*wf, cmid=64*wf)) for i in range(2, block_units[0] + 1)],
+                ))),
+                ('block2', nn.Sequential(OrderedDict(
+                        [('unit01', PreActBottleneck(cin=256*wf, cout=512*wf, cmid=128*wf, stride=2))] +
+                        [(f'unit{i:02d}', PreActBottleneck(cin=512*wf, cout=512*wf, cmid=128*wf)) for i in range(2, block_units[1] + 1)],
+                ))),
+                ('block3', nn.Sequential(OrderedDict(
+                        [('unit01', PreActBottleneck(cin=512*wf, cout=1024*wf, cmid=256*wf, stride=2))] +
+                        [(f'unit{i:02d}', PreActBottleneck(cin=1024*wf, cout=1024*wf, cmid=256*wf)) for i in range(2, block_units[2] + 1)],
+                ))),
+                ('block4', nn.Sequential(OrderedDict(
+                        [('unit01', PreActBottleneck(cin=1024*wf, cout=2048*wf, cmid=512*wf, stride=2))] +
+                        [(f'unit{i:02d}', PreActBottleneck(cin=2048*wf, cout=2048*wf, cmid=512*wf)) for i in range(2, block_units[3] + 1)],
+                ))),
+        ]))
+        # pylint: enable=line-too-long
+
+        self.head = nn.Sequential(OrderedDict([
+                ('gn', nn.GroupNorm(32, 2048*wf)),
+                ('relu', nn.ReLU(inplace=True)),
+                ('avg', nn.AdaptiveAvgPool2d(output_size=1)),
+                ('conv', nn.Conv2d(2048*wf, num_classes, kernel_size=1, bias=True)),
+        ]))
+        # fmt: on
+
+    def features(self, x):
+        return self.body(self.root(x))
+
+    def logits(self, x):
+        return self.head(x)
+
+    def forward(self, x):
+        x = self.logits(self.features(x))
+        assert x.shape[-2:] == (1, 1)  # We should have no spatial shape left.
+        return x[..., 0, 0]
+
+    def load_from(self, weights, prefix="resnet/"):
+        with torch.no_grad():
+            self.root.conv.weight.copy_(
+                tf2th(weights[f"{prefix}root_block/standardized_conv2d/kernel"])
+            )  # pylint: disable=line-too-long
+            self.head.gn.weight.copy_(tf2th(weights[f"{prefix}group_norm/gamma"]))
+            self.head.gn.bias.copy_(tf2th(weights[f"{prefix}group_norm/beta"]))
+            # always zero_head
+            nn.init.zeros_(self.head.conv.weight)
+            nn.init.zeros_(self.head.conv.bias)
+
+            for bname, block in self.body.named_children():
+                for uname, unit in block.named_children():
+                    unit.load_from(weights, prefix=f"{prefix}{bname}/{uname}/")
+
+
+KNOWN_MODELS = OrderedDict(
+    [
+        ("BiT-M-R50x1", lambda *a, **kw: ResNetV2([3, 4, 6, 3], 1, *a, **kw)),
+        ("BiT-M-R50x3", lambda *a, **kw: ResNetV2([3, 4, 6, 3], 3, *a, **kw)),
+        ("BiT-M-R101x1", lambda *a, **kw: ResNetV2([3, 4, 23, 3], 1, *a, **kw)),
+        ("BiT-M-R101x3", lambda *a, **kw: ResNetV2([3, 4, 23, 3], 3, *a, **kw)),
+        ("BiT-M-R152x2", lambda *a, **kw: ResNetV2([3, 8, 36, 3], 2, *a, **kw)),
+        ("BiT-M-R152x4", lambda *a, **kw: ResNetV2([3, 8, 36, 3], 4, *a, **kw)),
+        ("BiT-S-R50x1", lambda *a, **kw: ResNetV2([3, 4, 6, 3], 1, *a, **kw)),
+        ("BiT-S-R50x3", lambda *a, **kw: ResNetV2([3, 4, 6, 3], 3, *a, **kw)),
+        ("BiT-S-R101x1", lambda *a, **kw: ResNetV2([3, 4, 23, 3], 1, *a, **kw)),
+        ("BiT-S-R101x3", lambda *a, **kw: ResNetV2([3, 4, 23, 3], 3, *a, **kw)),
+        ("BiT-S-R152x2", lambda *a, **kw: ResNetV2([3, 8, 36, 3], 2, *a, **kw)),
+        ("BiT-S-R152x4", lambda *a, **kw: ResNetV2([3, 8, 36, 3], 4, *a, **kw)),
+    ]
+)
 
 
 PRETRAIN_SETTINGS = {
@@ -215,96 +217,99 @@ def load_from(self, weights, prefix='resnet/'):
 
 # fmt: off
 CFGS = {
-  # weights are loaded by default
-  "bit_m_50x1": {
-    "default": {
-      "params": {"block_units": [3, 4, 6, 3], "width_factor": 1},
-      "url": "https://storage.googleapis.com/bit_models/BiT-M-R50x1.npz",
-      **PRETRAIN_SETTINGS
+    # weights are loaded by default
+    "bit_m_50x1": {
+        "default": {
+            "params": {"block_units": [3, 4, 6, 3], "width_factor": 1},
+            "url": "https://storage.googleapis.com/bit_models/BiT-M-R50x1.npz",
+            **PRETRAIN_SETTINGS
+        },
     },
-  },
-  "bit_m_50x3": {
-    "default": {
-      "params": {"block_units": [3, 4, 6, 3], "width_factor": 3},
-      "url": "https://storage.googleapis.com/bit_models/BiT-M-R50x3.npz",
-      **PRETRAIN_SETTINGS,
+    "bit_m_50x3": {
+        "default": {
+            "params": {"block_units": [3, 4, 6, 3], "width_factor": 3},
+            "url": "https://storage.googleapis.com/bit_models/BiT-M-R50x3.npz",
+            **PRETRAIN_SETTINGS,
+        },
     },
-  },
-  "bit_m_101x1": {
-    "default": {
-      "params": {"block_units": [3, 4, 23, 3], "width_factor": 1},
-      "url": "https://storage.googleapis.com/bit_models/BiT-M-R101x1.npz",
-      **PRETRAIN_SETTINGS,
+    "bit_m_101x1": {
+        "default": {
+            "params": {"block_units": [3, 4, 23, 3], "width_factor": 1},
+            "url": "https://storage.googleapis.com/bit_models/BiT-M-R101x1.npz",
+            **PRETRAIN_SETTINGS,
+        },
     },
-  },
-  "bit_m_101x3": {
-    "default": {
-      "params": {"block_units": [3, 4, 23, 3], "width_factor": 3},
-      "url": "https://storage.googleapis.com/bit_models/BiT-M-R101x3.npz",
-      **PRETRAIN_SETTINGS,
+    "bit_m_101x3": {
+        "default": {
+            "params": {"block_units": [3, 4, 23, 3], "width_factor": 3},
+            "url": "https://storage.googleapis.com/bit_models/BiT-M-R101x3.npz",
+            **PRETRAIN_SETTINGS,
+        },
     },
-  },
-  "bit_m_152x2": {
-    "default": {
-      "params": {"block_units": [3, 8, 36, 3], "width_factor": 2},
-      "url": "https://storage.googleapis.com/bit_models/BiT-M-R152x2.npz",
-      **PRETRAIN_SETTINGS,
+    "bit_m_152x2": {
+        "default": {
+            "params": {"block_units": [3, 8, 36, 3], "width_factor": 2},
+            "url": "https://storage.googleapis.com/bit_models/BiT-M-R152x2.npz",
+            **PRETRAIN_SETTINGS,
+        },
     },
-  },
-  "bit_m_152x4": {
-    "default": {
-      "params": {"block_units": [3, 8, 36, 3], "width_factor": 4},
-      "url": "https://storage.googleapis.com/bit_models/BiT-M-R152x4.npz",
-      **PRETRAIN_SETTINGS
+    "bit_m_152x4": {
+        "default": {
+            "params": {"block_units": [3, 8, 36, 3], "width_factor": 4},
+            "url": "https://storage.googleapis.com/bit_models/BiT-M-R152x4.npz",
+            **PRETRAIN_SETTINGS
+        },
     },
-  },
 }
 
 # fmt: on
 def _bit_resnet(arch, pretrained=None, **kwargs):
-  cfgs = deepcopy(CFGS)
-  cfg_settings = cfgs[arch]["default"]
-  cfg_params = cfg_settings.pop("params")
-  cfg_url = cfg_settings.pop("url")
-  kwargs.pop("pretrained", None)
-  kwargs.update(cfg_params)
-  model = ResNetV2(**kwargs)
-  # load weights to torch checkpoints folder
-  try:
-      torch.hub.load_state_dict_from_url(cfg_url)
-  except RuntimeError:
-      pass # to avoid RuntimeError: Only one file(not dir) is allowed in the zipfile
-  filename = os.path.basename(urlparse(cfg_url).path)
-  torch_home = torch.hub._get_torch_home()
-  cached_file = os.path.join(torch_home, 'checkpoints', filename)
-  weights = np.load(cached_file)
-  model.load_from(weights)
-  return model
+    cfgs = deepcopy(CFGS)
+    cfg_settings = cfgs[arch]["default"]
+    cfg_params = cfg_settings.pop("params")
+    cfg_url = cfg_settings.pop("url")
+    kwargs.pop("pretrained", None)
+    kwargs.update(cfg_params)
+    model = ResNetV2(**kwargs)
+    # load weights to torch checkpoints folder
+    try:
+        torch.hub.load_state_dict_from_url(cfg_url)
+    except RuntimeError:
+        pass  # to avoid RuntimeError: Only one file(not dir) is allowed in the zipfile
+    filename = os.path.basename(urlparse(cfg_url).path)
+    torch_home = torch.hub._get_torch_home()
+    cached_file = os.path.join(torch_home, "checkpoints", filename)
+    weights = np.load(cached_file)
+    model.load_from(weights)
+    return model
+
 
 # only want M versions of models for fine-tuning
 @wraps(ResNetV2)
 def bit_m_50x1(**kwargs):
-  return _bit_resnet("bit_m_50x1", **kwargs)
+    return _bit_resnet("bit_m_50x1", **kwargs)
+
 
 @wraps(ResNetV2)
 def bit_m_50x3(**kwargs):
-  return _bit_resnet("bit_m_50x3", **kwargs)
+    return _bit_resnet("bit_m_50x3", **kwargs)
+
 
 @wraps(ResNetV2)
 def bit_m_101x1(**kwargs):
-  return _bit_resnet("bit_m_101x1", **kwargs)
+    return _bit_resnet("bit_m_101x1", **kwargs)
+
 
 @wraps(ResNetV2)
 def bit_m_101x3(**kwargs):
-  return _bit_resnet("bit_m_101x3", **kwargs)
+    return _bit_resnet("bit_m_101x3", **kwargs)
+
 
 @wraps(ResNetV2)
 def bit_m_152x2(**kwargs):
-  return _bit_resnet("bit_m_152x2", **kwargs)
+    return _bit_resnet("bit_m_152x2", **kwargs)
+
 
 @wraps(ResNetV2)
 def bit_m_152x4(**kwargs):
-  return _bit_resnet("bit_m_152x4", **kwargs)
-
-
-
+    return _bit_resnet("bit_m_152x4", **kwargs)
diff --git a/pytorch_tools/models/efficientnet.py b/pytorch_tools/models/efficientnet.py
index ca5e337..17e67c0 100644
--- a/pytorch_tools/models/efficientnet.py
+++ b/pytorch_tools/models/efficientnet.py
@@ -144,7 +144,7 @@ def __init__(
             self.dropout = nn.Dropout(drop_rate, inplace=True)
             self.classifier = nn.Linear(num_features, num_classes)
 
-        patch_bn(self) # adjust epsilon
+        patch_bn(self)  # adjust epsilon
         initialize(self)
         if match_tf_same_padding:
             conv_to_same_conv(self)
@@ -397,7 +397,8 @@ def patch_bn(module):
         module.eps = 1e-3
     for m in module.children():
         patch_bn(m)
-  
+
+
 def _efficientnet(arch, pretrained=None, **kwargs):
     cfgs = deepcopy(CFGS)
     cfg_settings = cfgs[arch]["default"]
@@ -426,8 +427,10 @@ def _efficientnet(arch, pretrained=None, **kwargs):
             )
             state_dict["classifier.weight"] = model.state_dict()["classifier.weight"]
             state_dict["classifier.bias"] = model.state_dict()["classifier.bias"]
-        if kwargs.get("in_channels", 3) != 3: # support pretrained for custom input channels
-            state_dict["conv_stem.weight"] = repeat_channels(state_dict["conv_stem.weight"], kwargs["in_channels"])
+        if kwargs.get("in_channels", 3) != 3:  # support pretrained for custom input channels
+            state_dict["conv_stem.weight"] = repeat_channels(
+                state_dict["conv_stem.weight"], kwargs["in_channels"]
+            )
         model.load_state_dict(state_dict)
     setattr(model, "pretrained_settings", cfg_settings)
     return model
diff --git a/pytorch_tools/models/hrnet.py b/pytorch_tools/models/hrnet.py
index 0a65182..cbf5817 100644
--- a/pytorch_tools/models/hrnet.py
+++ b/pytorch_tools/models/hrnet.py
@@ -43,22 +43,23 @@ def make_layer(inplanes, planes, blocks, norm_layer=ABN, norm_act="relu"):
     layers = []
     layers.append(block(inplanes, planes, downsample=downsample, **bn_args))
     inplanes = planes * block.expansion
-    for i in range(1, blocks):
+    for _ in range(1, blocks):
         layers.append(block(inplanes, planes, **bn_args))
     return nn.Sequential(*layers)
 
+
 class HighResolutionModule(nn.Module):
     def __init__(
-        self, 
-        num_branches, # number of parallel branches
-        num_blocks, # number of blocks
+        self,
+        num_branches,  # number of parallel branches
+        num_blocks,  # number of blocks
         num_channels,
         norm_layer=ABN,
         norm_act="relu",
     ):
         super(HighResolutionModule, self).__init__()
         self.block = BasicBlock
-        self.num_branches = num_branches # used in forward
+        self.num_branches = num_branches  # used in forward
         self.num_inchannels = num_channels
         self.bn_args = {"norm_layer": norm_layer, "norm_act": norm_act}
         branches = [self._make_branch(n_bl, n_ch) for n_bl, n_ch in zip(num_blocks, num_channels)]
@@ -69,6 +70,7 @@ def __init__(
     def _make_branch(self, b_blocks, b_channels):
         return nn.Sequential(*[self.block(b_channels, b_channels, **self.bn_args) for _ in range(b_blocks)])
 
+    # fmt: off
     # don't want to rewrite this piece it's too fragile
     def _make_fuse_layers(self, norm_layer, norm_act):
         if self.num_branches == 1:
@@ -104,23 +106,24 @@ def _make_fuse_layers(self, norm_layer, norm_act):
             fuse_layers.append(nn.ModuleList(fuse_layer))
 
         return nn.ModuleList(fuse_layers)
-
+    # fmt: on
 
     def forward(self, x):
         if self.num_branches == 1:
             return [self.branches[0](x[0])]
-        
+
         x = [branch(x_i) for branch, x_i in zip(self.branches, x)]
 
         x_fuse = []
         for i in range(len(self.fuse_layers)):
             y = x[0] if i == 0 else self.fuse_layers[i][0](x[0])
             for j in range(1, self.num_branches):
-                    y = y + self.fuse_layers[i][j](x[j])
+                y = y + self.fuse_layers[i][j](x[j])
             x_fuse.append(self.relu(y))
 
         return x_fuse
 
+
 class TransitionBlock(nn.Module):
     """Transition is where new branches for smaller resolution are born
     -- ==> --
@@ -129,7 +132,7 @@ class TransitionBlock(nn.Module):
       \
        \=> --
     """
-    
+
     def __init__(self, prev_channels, current_channels, norm_layer=ABN, norm_act="relu"):
         super().__init__()
         transition_layers = []
@@ -140,40 +143,40 @@ def __init__(self, prev_channels, current_channels, norm_layer=ABN, norm_act="re
                 transition_layers.append(nn.Sequential(*layers))
             else:
                 transition_layers.append(nn.Identity())
-                
-        if len(current_channels) > len(prev_channels): # only works for ONE extra branch
+
+        if len(current_channels) > len(prev_channels):  # only works for ONE extra branch
             layers = [
-                conv3x3(prev_channels[-1], current_channels[-1], 2), 
-                norm_layer(current_channels[-1], activation=norm_act)
+                conv3x3(prev_channels[-1], current_channels[-1], 2),
+                norm_layer(current_channels[-1], activation=norm_act),
             ]
             transition_layers.append(nn.Sequential(*layers))
         self.trans_layers = nn.ModuleList(transition_layers)
-        
-    def forward(self, x): # x is actually an array
+
+    def forward(self, x):  # x is actually an array
         out_x = [trans_l(x_i) for x_i, trans_l in zip(x, self.trans_layers)]
         out_x.append(self.trans_layers[-1](x[-1]))
         return out_x
 
+
 class HRClassificationHead(nn.Module):
     def __init__(self, pre_channels, norm_layer=ABN, norm_act="relu"):
         super().__init__()
         head_block = Bottleneck
         head_channels = [32, 64, 128, 256]
-        # Increasing the #channels on each resolution 
+        # Increasing the #channels on each resolution
         # from C, 2C, 4C, 8C to 128, 256, 512, 1024
         incre_modules = []
         for (pre_c, head_c) in zip(pre_channels, head_channels):
             incre_modules.append(make_layer(pre_c, head_c, 1, norm_layer, norm_act))
         self.incre_modules = nn.ModuleList(incre_modules)
-        
+
         # downsampling modules
         downsamp_modules = []
-        for i in range(len(pre_channels)-1):
+        for i in range(len(pre_channels) - 1):
             in_ch = head_channels[i] * head_block.expansion
-            out_ch = head_channels[i+1] * head_block.expansion
+            out_ch = head_channels[i + 1] * head_block.expansion
             downsamp_module = nn.Sequential(
-                conv3x3(in_ch, out_ch, 2, bias=True),
-                norm_layer(out_ch, activation=norm_act)
+                conv3x3(in_ch, out_ch, 2, bias=True), norm_layer(out_ch, activation=norm_act)
             )
             downsamp_modules.append(downsamp_module)
         self.downsamp_modules = nn.ModuleList(downsamp_modules)
@@ -182,13 +185,13 @@ def __init__(self, pre_channels, norm_layer=ABN, norm_act="relu"):
             conv1x1(head_channels[3] * head_block.expansion, 2048, bias=True),
             norm_layer(2048, activation=norm_act),
         )
-        
+
     def forward(self, x):
-        x = [self.incre_modules[i](x[i]) for i in range(4)]        
+        x = [self.incre_modules[i](x[i]) for i in range(4)]
         for i in range(1, 4):
-            x[i] = x[i] + self.downsamp_modules[i-1](x[i-1])
+            x[i] = x[i] + self.downsamp_modules[i - 1](x[i - 1])
         return self.final_layer(x[3])
-    
+
 
 class HighResolutionNet(nn.Module):
     """HighResolution Nets constructor
@@ -219,13 +222,14 @@ class HighResolutionNet(nn.Module):
             NOTE: HRNet first features have resolution 4x times smaller than input, not 2x as all other models. 
             So it CAN'T be used as encoder in Unet and Linknet models 
     """
-        # drop_rate (float):
-        #     Dropout probability before classifier, for training. Defaults to 0.
+
+    # drop_rate (float):
+    #     Dropout probability before classifier, for training. Defaults to 0.
     def __init__(
-        self, 
+        self,
         width=18,
         small=False,
-        pretrained=None, # not used. here for proper signature
+        pretrained=None,  # not used. here for proper signature
         num_classes=1000,
         in_channels=3,
         norm_layer="abn",
@@ -241,27 +245,25 @@ def __init__(
 
         self.conv2 = conv3x3(stem_width, stem_width, stride=2)
         self.bn2 = norm_layer(stem_width, activation=norm_act)
-        
+
         channels = [width, width * 2, width * 4, width * 8]
         n_blocks = [2 if small else 4] * 4
-        
+
         self.layer1 = make_layer(stem_width, stem_width, n_blocks[0], **bn_args)
-        
+
         self.transition1 = TransitionBlock([stem_width * Bottleneck.expansion], channels[:2], **bn_args)
-        self.stage2 = self._make_stage(
-            n_modules=1, n_branches=2, n_blocks=n_blocks[:2], n_chnls=channels[:2]
-        )
-        
+        self.stage2 = self._make_stage(n_modules=1, n_branches=2, n_blocks=n_blocks[:2], n_chnls=channels[:2])
+
         self.transition2 = TransitionBlock(channels[:2], channels[:3], **bn_args)
-        self.stage3 = self._make_stage( # 3 if small else 4
-            n_modules=(4,3)[small], n_branches=3, n_blocks=n_blocks[:3], n_chnls=channels[:3]
+        self.stage3 = self._make_stage(  # 3 if small else 4
+            n_modules=(4, 3)[small], n_branches=3, n_blocks=n_blocks[:3], n_chnls=channels[:3]
         )
-        
+
         self.transition3 = TransitionBlock(channels[:3], channels, **bn_args)
-        self.stage4 = self._make_stage( # 2 if small else 3
-            n_modules=(3,2)[small], n_branches=4, n_blocks=n_blocks, n_chnls=channels,
+        self.stage4 = self._make_stage(  # 2 if small else 3
+            n_modules=(3, 2)[small], n_branches=4, n_blocks=n_blocks, n_chnls=channels,
         )
-        
+
         self.encoder = encoder
         if encoder:
             self.forward = self.encoder_features
@@ -276,16 +278,9 @@ def __init__(
     def _make_stage(self, n_modules, n_branches, n_blocks, n_chnls):
         modules = []
         for i in range(n_modules):
-            modules.append(
-                HighResolutionModule(
-                    n_branches,
-                    n_blocks,
-                    n_chnls,
-                    **self.bn_args,
-                )
-            )
+            modules.append(HighResolutionModule(n_branches, n_blocks, n_chnls, **self.bn_args,))
         return nn.Sequential(*modules)
-    
+
     def encoder_features(self, x):
         # stem
         x = self.conv1(x)
@@ -293,46 +288,46 @@ def encoder_features(self, x):
         x = self.conv2(x)
         x = self.bn2(x)
         x = self.layer1(x)
-        
-        x = self.transition1([x]) # x is actually a list now
+
+        x = self.transition1([x])  # x is actually a list now
         x = self.stage2(x)
-        
+
         x = self.transition2(x)
         x = self.stage3(x)
-        
+
         x = self.transition3(x)
         x = self.stage4(x)
-        if self.encoder: # want to return from lowest resolution to highest
+        if self.encoder:  # want to return from lowest resolution to highest
             x = [x[3], x[2], x[1], x[0], x[0]]
         return x
-    
+
     def features(self, x):
         x = self.encoder_features(x)
         x = self.cls_head(x)
         return x
-    
+
     def logits(self, x):
         x = self.global_pool(x)
         x = torch.flatten(x, 1)
-#         x = self.dropout(x)
+        #         x = self.dropout(x)
         x = self.last_linear(x)
         return x
-    
+
     def forward(self, x):
         x = self.features(x)
         x = self.logits(x)
         return x
-    
+
     def load_state_dict(self, state_dict, **kwargs):
         self_keys = list(self.state_dict().keys())
         sd_keys = list(state_dict.keys())
-        sd_keys = [k for k in sd_keys if "num_batches_tracked" not in k] # filter
+        sd_keys = [k for k in sd_keys if "num_batches_tracked" not in k]  # filter
         new_state_dict = {}
         for new_key, old_key in zip(self_keys, sd_keys):
             new_state_dict[new_key] = state_dict[old_key]
         super().load_state_dict(new_state_dict, **kwargs)
-        
-        
+
+
 # fmt: off
 CFGS = {
     "hrnet_w18_small": {
@@ -368,9 +363,10 @@ def load_state_dict(self, state_dict, **kwargs):
         "imagenet": {"url": None},
     },
 }
-    
+
 # fmt:on
-        
+
+
 def _hrnet(arch, pretrained=None, **kwargs):
     cfgs = deepcopy(CFGS)
     cfg_settings = cfgs[arch]["default"]
@@ -420,7 +416,7 @@ def hrnet_w18_small(**kwargs):
 def hrnet_w18(**kwargs):
     r"""Constructs a HRNetv2-18 model."""
     return _hrnet("hrnet_w18", **kwargs)
-    
+
 
 @wraps(HighResolutionNet)
 @add_docs_for(HighResolutionNet)
@@ -428,33 +424,37 @@ def hrnet_w30(**kwargs):
     r"""Constructs a HRNetv2-30 model."""
     return _hrnet("hrnet_w30", **kwargs)
 
+
 @wraps(HighResolutionNet)
 @add_docs_for(HighResolutionNet)
 def hrnet_w32(**kwargs):
     r"""Constructs a HRNetv2-32 model."""
     return _hrnet("hrnet_w32", **kwargs)
 
+
 @wraps(HighResolutionNet)
 @add_docs_for(HighResolutionNet)
 def hrnet_w40(**kwargs):
     r"""Constructs a HRNetv2-40 model."""
     return _hrnet("hrnet_w40", **kwargs)
 
+
 @wraps(HighResolutionNet)
 @add_docs_for(HighResolutionNet)
 def hrnet_w44(**kwargs):
     r"""Constructs a HRNetv2-44 model."""
     return _hrnet("hrnet_w44", **kwargs)
 
+
 @wraps(HighResolutionNet)
 @add_docs_for(HighResolutionNet)
 def hrnet_w48(**kwargs):
     r"""Constructs a HRNetv2-48 model."""
     return _hrnet("hrnet_w48", **kwargs)
 
+
 @wraps(HighResolutionNet)
 @add_docs_for(HighResolutionNet)
 def hrnet_w64(**kwargs):
     r"""Constructs a HRNetv2-64 model."""
     return _hrnet("hrnet_w64", **kwargs)
-
diff --git a/pytorch_tools/models/resnet.py b/pytorch_tools/models/resnet.py
index 0490cb6..bdc9e57 100644
--- a/pytorch_tools/models/resnet.py
+++ b/pytorch_tools/models/resnet.py
@@ -214,7 +214,7 @@ def _make_stem(self, stem_type, stem_width, in_channels, norm_layer, norm_act):
             # in the paper they use conv1x1 but in code conv3x3 (which seems better)
             self.conv1 = nn.Sequential(SpaceToDepth(), conv3x3(in_channels * 16, stem_width))
             self.bn1 = norm_layer(stem_width, activation=norm_act)
-            self.maxpool = nn.Identity() # not used but needed for code compatability
+            self.maxpool = nn.Identity()  # not used but needed for code compatability
         else:
             if stem_type == "deep":
                 self.conv1 = nn.Sequential(
@@ -225,7 +225,9 @@ def _make_stem(self, stem_type, stem_width, in_channels, norm_layer, norm_act):
                     conv3x3(stem_width // 2, stem_width),
                 )
             else:
-                self.conv1 = nn.Conv2d(in_channels, stem_width, kernel_size=7, stride=2, padding=3, bias=False)
+                self.conv1 = nn.Conv2d(
+                    in_channels, stem_width, kernel_size=7, stride=2, padding=3, bias=False
+                )
             self.bn1 = norm_layer(stem_width, activation=norm_act)
             self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
 
@@ -296,6 +298,7 @@ def keep_prob(self):
         self.block_idx += 1
         return keep_prob
 
+
 # fmt: off
 CFGS = {
     # RESNET MODELS
diff --git a/pytorch_tools/models/tresnet.py b/pytorch_tools/models/tresnet.py
index 022c9b0..9be0c36 100644
--- a/pytorch_tools/models/tresnet.py
+++ b/pytorch_tools/models/tresnet.py
@@ -19,6 +19,7 @@
 # avoid overwriting doc string
 wraps = partial(wraps, assigned=("__module__", "__name__", "__qualname__", "__annotations__"))
 
+
 class TResNet(ResNet):
     """TResNet M / TResNet L / XL
 
@@ -71,13 +72,13 @@ def __init__(
         drop_rate=0.0,
         drop_connect_rate=0.0,
     ):
-        nn.Module.__init__(self) 
+        nn.Module.__init__(self)
         stem_width = int(64 * width_factor)
         norm_layer = bn_from_name(norm_layer)
         self.inplanes = stem_width
         self.num_classes = num_classes
-        self.groups = 1 # not really used but needed inside _make_layer
-        self.base_width = 64 # used inside _make_layer
+        self.groups = 1  # not really used but needed inside _make_layer
+        self.base_width = 64  # used inside _make_layer
         self.norm_act = norm_act
         self.block_idx = 0
         self.num_blocks = sum(layers)
@@ -89,9 +90,9 @@ def __init__(
             raise ValueError("Output stride should be in [8, 16, 32]")
         # TODO add OS later
         # if output_stride == 8:
-            # stride_3, stride_4, dilation_3, dilation_4 = 1, 1, 2, 4
+        # stride_3, stride_4, dilation_3, dilation_4 = 1, 1, 2, 4
         # elif output_stride == 16:
-            # stride_3, stride_4, dilation_3, dilation_4 = 2, 1, 1, 2
+        # stride_3, stride_4, dilation_3, dilation_4 = 2, 1, 1, 2
         # elif output_stride == 32:
         stride_3, stride_4, dilation_3, dilation_4 = 2, 2, 1, 1
 
@@ -101,11 +102,15 @@ def __init__(
         self.layer1 = self._make_layer(stem_width, layers[0], stride=1, **largs)
         self.layer2 = self._make_layer(stem_width * 2, layers[1], stride=2, **largs)
 
-        self.block = TBottleneck # first 2 - Basic, last 2 - Bottleneck
+        self.block = TBottleneck  # first 2 - Basic, last 2 - Bottleneck
         self.expansion = TBottleneck.expansion
-        self.layer3 = self._make_layer(stem_width * 4, layers[2], stride=stride_3, dilation=dilation_3, **largs)
-        largs.update(attn_type=None) # no se in last layer
-        self.layer4 = self._make_layer(stem_width * 8, layers[3], stride=stride_4, dilation=dilation_4, **largs)
+        self.layer3 = self._make_layer(
+            stem_width * 4, layers[2], stride=stride_3, dilation=dilation_3, **largs
+        )
+        largs.update(attn_type=None)  # no se in last layer
+        self.layer4 = self._make_layer(
+            stem_width * 8, layers[3], stride=stride_4, dilation=dilation_4, **largs
+        )
         self.global_pool = FastGlobalAvgPool2d(flatten=True)
         self.num_features = stem_width * 8 * self.expansion
         self.encoder = encoder
@@ -123,6 +128,7 @@ def load_state_dict(self, state_dict, **kwargs):
             state_dict.pop("last_linear.bias")
         nn.Module.load_state_dict(self, state_dict, **kwargs)
 
+
 # fmt: off
 # images should be normalized to [0, 1]
 PRETRAIN_SETTINGS = {
@@ -169,6 +175,7 @@ def load_state_dict(self, state_dict, **kwargs):
 }
 # fmt: on
 
+
 def patch_bn(module):
     """changes weight from InplaceABN to be compatible with usual ABN"""
     if isinstance(module, ABN):
@@ -176,6 +183,7 @@ def patch_bn(module):
     for m in module.children():
         patch_bn(m)
 
+
 def _resnet(arch, pretrained=None, **kwargs):
     cfgs = deepcopy(CFGS)
     cfg_settings = cfgs[arch]["default"]
@@ -204,27 +212,32 @@ def _resnet(arch, pretrained=None, **kwargs):
             # if there is last_linear in state_dict, it's going to be overwritten
             state_dict["last_linear.weight"] = model.state_dict()["last_linear.weight"]
             state_dict["last_linear.bias"] = model.state_dict()["last_linear.bias"]
-        if kwargs.get("in_channels", 3) != 3: # support pretrained for custom input channels
-            state_dict["conv1.1.weight"] = repeat_channels(state_dict["conv1.1.weight"], kwargs["in_channels"] * 16, 3 * 16)
+        if kwargs.get("in_channels", 3) != 3:  # support pretrained for custom input channels
+            state_dict["conv1.1.weight"] = repeat_channels(
+                state_dict["conv1.1.weight"], kwargs["in_channels"] * 16, 3 * 16
+            )
         model.load_state_dict(state_dict)
         patch_bn(model)
     setattr(model, "pretrained_settings", cfg_settings)
     return model
 
+
 @wraps(TResNet)
 @add_docs_for(TResNet)
 def tresnetm(**kwargs):
     r"""Constructs a TResnetM model."""
     return _resnet("tresnetm", **kwargs)
 
+
 @wraps(TResNet)
 @add_docs_for(TResNet)
 def tresnetl(**kwargs):
     r"""Constructs a TResnetL model."""
     return _resnet("tresnetl", **kwargs)
 
+
 @wraps(TResNet)
 @add_docs_for(TResNet)
 def tresnetxl(**kwargs):
     r"""Constructs a TResnetXL model."""
-    return _resnet("tresnetxl", **kwargs)
\ No newline at end of file
+    return _resnet("tresnetxl", **kwargs)
diff --git a/pytorch_tools/models/vgg.py b/pytorch_tools/models/vgg.py
index b2037ce..0f17b85 100644
--- a/pytorch_tools/models/vgg.py
+++ b/pytorch_tools/models/vgg.py
@@ -90,7 +90,6 @@ def forward(self, x):
         x = self.logits(x)
         return x
 
-
     def _make_layers(self, cfg):
         layers = []
         in_channels = self.in_channels
diff --git a/pytorch_tools/modules/activated_batch_norm.py b/pytorch_tools/modules/activated_batch_norm.py
index f4e0786..586ae0d 100644
--- a/pytorch_tools/modules/activated_batch_norm.py
+++ b/pytorch_tools/modules/activated_batch_norm.py
@@ -46,7 +46,7 @@ def __init__(
         self.activation = ACT(activation)
         self.activation_param = activation_param
         self.frozen = frozen
-        
+
         if frozen:
             self.register_buffer("weight", torch.ones(num_features))
             self.register_buffer("bias", torch.zeros(num_features))
diff --git a/pytorch_tools/modules/tf_same_ops.py b/pytorch_tools/modules/tf_same_ops.py
index 1c5adb6..cfb8026 100644
--- a/pytorch_tools/modules/tf_same_ops.py
+++ b/pytorch_tools/modules/tf_same_ops.py
@@ -5,6 +5,7 @@
 import torch.nn.functional as F
 from torch.nn.modules.utils import _pair
 
+
 def pad_same(x, k, s, d, value=0):
     # type: (Tensor, int, int, int, float)->Tensor
     # x - input tensor, s - stride, k - kernel_size, d - dilation
@@ -15,26 +16,31 @@ def pad_same(x, k, s, d, value=0):
         x = F.pad(x, [pad_w // 2, pad_w - pad_w // 2, pad_h // 2, pad_h - pad_h // 2], value=value)
     return x
 
-# current implementation is only for symmetric case. But there are no non symmetric cases 
+
+# current implementation is only for symmetric case. But there are no non symmetric cases
 def conv2d_same(x, weight, bias=None, stride=(1, 1), dilation=(1, 1), groups=1):
     # type: (Tensor, Tensor, Optional[torch.Tensor], Tuple[int, int], Tuple[int, int], int)->Tensor
     x = pad_same(x, weight.shape[-1], stride[0], dilation[0])
     return F.conv2d(x, weight, bias, stride, (0, 0), dilation, groups)
 
+
 def maxpool2d_same(x, kernel_size, stride):
     # type: (Tensor, Tuple[int, int], Tuple[int, int])->Tensor
-    x = pad_same(x, kernel_size[0], stride[0], 1, value=-float('inf'))
+    x = pad_same(x, kernel_size[0], stride[0], 1, value=-float("inf"))
     return F.max_pool2d(x, kernel_size, stride, (0, 0))
 
+
 class Conv2dSamePadding(nn.Conv2d):
     """Assymetric padding matching TensorFlow `same`"""
 
     def forward(self, x):
         return conv2d_same(x, self.weight, self.bias, self.stride, self.dilation, self.groups)
 
-# as of 1.5 there is no _pair in MaxPool. Remove when this is fixed 
+
+# as of 1.5 there is no _pair in MaxPool. Remove when this is fixed
 class MaxPool2dSamePadding(nn.MaxPool2d):
     """Assymetric padding matching TensorFlow `same`"""
+
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.kernel_size = _pair(self.kernel_size)
diff --git a/pytorch_tools/utils/box.py b/pytorch_tools/utils/box.py
index 73bb377..16b349e 100644
--- a/pytorch_tools/utils/box.py
+++ b/pytorch_tools/utils/box.py
@@ -3,6 +3,7 @@
 import numpy as np
 from functools import wraps
 
+
 def box2delta(boxes, anchors):
     # type: (Tensor, Tensor)->Tensor
     """Convert boxes to deltas from anchors. Boxes are expected in 'ltrb' format
@@ -14,9 +15,9 @@ def box2delta(boxes, anchors):
             offset_x, offset_y, scale_x, scale_y
     """
 
-    anchors_wh = anchors[..., 2:] - anchors[..., :2] # + 1
+    anchors_wh = anchors[..., 2:] - anchors[..., :2]
     anchors_ctr = anchors[..., :2] + 0.5 * anchors_wh
-    boxes_wh = boxes[..., 2:] - boxes[..., :2] # + 1
+    boxes_wh = boxes[..., 2:] - boxes[..., :2]
     boxes_ctr = boxes[..., :2] + 0.5 * boxes_wh
     offset_delta = (boxes_ctr - anchors_ctr) / anchors_wh
     scale_delta = torch.log(boxes_wh / anchors_wh)
@@ -40,7 +41,7 @@ def delta2box(deltas, anchors):
     # Value for clamping large dw and dh predictions. The heuristic is that we clamp
     # such that dw and dh are no larger than what would transform a 16px box into a
     # 1000px box (based on a small anchor, 16px, and a typical image size, 1000px).
-    SCALE_CLAMP = 4.135 # ~= np.log(1000. / 16.)
+    SCALE_CLAMP = 4.135  # ~= np.log(1000. / 16.)
     deltas[..., 2:] = deltas[..., 2:].clamp(min=-SCALE_CLAMP, max=SCALE_CLAMP)
 
     pred_wh = deltas[..., 2:].exp() * anchors_wh
@@ -53,6 +54,7 @@ def box_area(box):
     """
     return (box[..., 2] - box[..., 0]) * (box[..., 3] - box[..., 1])
 
+
 def clip_bboxes(bboxes, size):
     """Args:
         bboxes (torch.Tensor): in `ltrb` format. Shape [N, 4]
@@ -61,14 +63,15 @@ def clip_bboxes(bboxes, size):
     bboxes[:, 1::2] = bboxes[:, 1::2].clamp(0, size[0])
     return bboxes
 
+
 def clip_bboxes_batch(bboxes, size):
     # type: (Tensor, Tensor)->Tensor
     """Args:
         bboxes (torch.Tensor): in `ltrb` format. Shape [BS, N, 4]
         size (torch.Tensor): (H, W). Shape [BS, 2] """
     size = size.to(bboxes)
-    h_size = size[..., 0].view(-1, 1, 1) #.float()
-    w_size = size[..., 1].view(-1, 1, 1) #.float()
+    h_size = size[..., 0].view(-1, 1, 1)  # .float()
+    w_size = size[..., 1].view(-1, 1, 1)  # .float()
     h_bboxes = bboxes[..., 1::2]
     w_bboxes = bboxes[..., 0::2]
     zeros = torch.zeros_like(h_bboxes)
@@ -79,6 +82,7 @@ def clip_bboxes_batch(bboxes, size):
     # bboxes[:, 1::2] = bboxes[:, 1::2].clamp(0, size[0].item())
     return bboxes
 
+
 # implementation from https://github.com/kuangliu/torchcv/blob/master/torchcv/utils/box.py
 # with slight modifications
 def box_iou(boxes1, boxes2):
@@ -107,13 +111,9 @@ def box_iou(boxes1, boxes2):
 
 
 # based on https://github.com/NVIDIA/retinanet-examples/
-# and on https://github.com/google/automl/ 
+# and on https://github.com/google/automl/
 def generate_anchors_boxes(
-    image_size, 
-    num_scales=3,
-    aspect_ratios=(1.0, 2.0, 0.5),
-    pyramid_levels=[3, 4, 5, 6, 7],
-    anchor_scale=4,
+    image_size, num_scales=3, aspect_ratios=(1.0, 2.0, 0.5), pyramid_levels=[3, 4, 5, 6, 7], anchor_scale=4,
 ):
     """Generates multiscale anchor boxes
     Minimum object size which could be detected is anchor_scale * 2**pyramid_levels[0]. By default it's 32px
@@ -132,28 +132,28 @@ def generate_anchors_boxes(
             boxes are in 'ltrb' format
         num_anchors (int): number of anchors per location
     """
-    
+
     if isinstance(image_size, int):
         image_size = (image_size, image_size)
     scale_vals = [anchor_scale * 2 ** (i / num_scales) for i in range(num_scales)]
     # from lowest stride to largest. Anchors from models should be in the same order!
-    strides = [2**i for i in pyramid_levels]
-    
+    strides = [2 ** i for i in pyramid_levels]
+
     # get offsets for anchor boxes for one pixel
     # can rewrite in pure Torch but using np is more convenient. This function usually should only be called once
     num_anchors = len(scale_vals) * len(aspect_ratios)
     ratio_vals_sq = np.sqrt(np.tile(aspect_ratios, len(scale_vals)))
     scale_vals = np.repeat(scale_vals, len(aspect_ratios))[:, np.newaxis]
-    wh = np.stack([np.ones(num_anchors) * ratio_vals_sq, np.ones(num_anchors) / ratio_vals_sq], axis=1) 
-    lt = - 0.5 * wh * scale_vals
+    wh = np.stack([np.ones(num_anchors) * ratio_vals_sq, np.ones(num_anchors) / ratio_vals_sq], axis=1)
+    lt = -0.5 * wh * scale_vals
     rb = 0.5 * wh * scale_vals
-    base_offsets = torch.from_numpy(np.hstack([lt, rb])).float() # [num_anchors, 4]
-    base_offsets = base_offsets.view(-1, 1, 1, 4) # [num_anchors, 1, 1, 4]
+    base_offsets = torch.from_numpy(np.hstack([lt, rb])).float()  # [num_anchors, 4]
+    base_offsets = base_offsets.view(-1, 1, 1, 4)  # [num_anchors, 1, 1, 4]
     # generate anchor boxes for all given strides
     all_anchors = []
     for stride in strides:
         y, x = torch.meshgrid([torch.arange(stride / 2, image_size[i], stride) for i in range(2)])
-        xyxy = torch.stack((x, y, x, y), 2).unsqueeze(0) 
+        xyxy = torch.stack((x, y, x, y), 2).unsqueeze(0)
         # permute to match TF EffDet anchors order after reshape
         anchors = (xyxy + base_offsets * stride).permute(1, 2, 0, 3).reshape(-1, 4)
         all_anchors.append(anchors)
@@ -162,6 +162,7 @@ def generate_anchors_boxes(
     # clip_bboxes(all_anchors, image_size)
     return all_anchors, num_anchors
 
+
 def generate_targets(anchors, batch_gt_boxes, num_classes, matched_iou=0.5, unmatched_iou=0.4):
     """Generate targets for regression and classification
     
@@ -169,34 +170,35 @@ def generate_targets(anchors, batch_gt_boxes, num_classes, matched_iou=0.5, unma
     1) IoU >= matched_iou: Highest similarity. Matched/Positive. Mask value is 1
     2) matched_iou > IoU >= unmatched_iou: Medium similarity. Ignored. Mask value is -1
     3) unmatched_iou > IoU: Lowest similarity. Unmatched/Negative. Mask value is 0
-    
+
     Args:
         anchors (torch.Tensor): all anchors on a single image. shape [N, 4]
-        batch_gt_boxes (torch.Tesor): all groud truth bounding boxes and classes for the batch. shape [BS, N, 5]
-            classes are expected to be in the last column. 
+        batch_gt_boxes (torch.Tensor): all ground truth bounding boxes and classes for the batch. shape [BS, N, 5]
+            classes are expected to be in the last column.
             bboxes are in `ltrb` format!
         num_classes (int): number of classes. needed for one-hot encoding labels
-        matched_iou (float):  
+        matched_iou (float):
         unmatched_iou (float):
-    
+
     Returns:
         box_target, cls_target, matches_mask
-    
+
     """
+
     def _generate_single_targets(gt_boxes):
         gt_boxes, gt_classes = gt_boxes.split(4, dim=1)
         overlap = box_iou(anchors, gt_boxes)
-        
+
         # Keep best box per anchor
         overlap, indices = overlap.max(1)
         box_target = box2delta(gt_boxes[indices], anchors)
-        
-        # There are three types of anchors. 
+
+        # There are three types of anchors.
         # matched (with objects), unmatched (with background), and in between (which should be ignored)
         IGNORED_VALUE = -1
         UNMATCHED_VALUE = 0
         matches_mask = torch.ones_like(overlap) * IGNORED_VALUE
-        matches_mask[overlap < unmatched_iou] = UNMATCHED_VALUE # background
+        matches_mask[overlap < unmatched_iou] = UNMATCHED_VALUE  # background
         matches_mask[overlap >= matched_iou] = 1
 
         # Generate one-hot-encoded target classes
@@ -206,11 +208,11 @@ def _generate_single_targets(gt_boxes):
         gt_classes = gt_classes[indices].long()
         gt_classes[overlap < unmatched_iou] = num_classes  # background has no class
         cls_target.scatter_(1, gt_classes, 1)
-        cls_target = cls_target[:, :num_classes] # remove background class from one-hot
+        cls_target = cls_target[:, :num_classes]  # remove background class from one-hot
 
         return cls_target, box_target, matches_mask
-    
-    anchors = anchors.to(batch_gt_boxes) # change device & type if needed
+
+    anchors = anchors.to(batch_gt_boxes)  # change device & type if needed
     batch_results = ([], [], [])
     for single_gt_boxes in batch_gt_boxes:
         single_target_results = _generate_single_targets(single_gt_boxes)
@@ -218,7 +220,8 @@ def _generate_single_targets(gt_boxes):
             batch_res.append(single_res)
     b_cls_target, b_box_target, b_matches_mask = [torch.stack(targets) for targets in batch_results]
     return b_cls_target, b_box_target, b_matches_mask
-    
+
+
 # copied from torchvision
 def batched_nms(boxes, scores, idxs, iou_threshold):
     # type: (Tensor, Tensor, Tensor, float)->Tensor
@@ -257,9 +260,10 @@ def batched_nms(boxes, scores, idxs, iou_threshold):
     keep = torch.ops.torchvision.nms(boxes_for_nms, scores, iou_threshold)
     return keep
 
+
 # jit actually makes it slower for fp16 and results are different!
 # FIXME: check it after 1.6 release. maybe they will fix JIT by that time
-# @torch.jit.script 
+# @torch.jit.script
 def decode(
     batch_cls_head,
     batch_box_head,
@@ -274,8 +278,8 @@ def decode(
     # type: (Tensor, Tensor, Tensor, Tensor, Tensor, float, int, int, float)->Tensor
     """
     Decodes raw outputs of a model for easy visualization of bboxes
-    
-    Args: 
+
+    Args:
         batch_cls_head (torch.Tensor): shape [BS, *, NUM_CLASSES]
         batch_box_head (torch.Tensor): shape [BS, *, 4]
         anchors (torch.Tensor): shape [*, 4]
@@ -285,25 +289,27 @@ def decode(
         max_detection_points (int): Maximum number of bboxes to consider for NMS for one image
         max_detection_per_image (int): Maximum number of bboxes to return per image 
         iou_threshold (float): iou_threshold for Non Maximum Supression
-        
+
     Returns:
         torch.Tensor with bboxes, scores and classes
             shape [BS, MAX_DETECTION_PER_IMAGE, 6]. 
             bboxes in 'ltrb' format. If img_shape is not given they are NOT CLIPPED (!)
     """
-    
+
     batch_size = batch_cls_head.size(0)
     num_classes = batch_cls_head.size(-1)
 
-    anchors = anchors.to(batch_cls_head).unsqueeze(0).expand(batch_size, -1, -1) # [N, 4] -> [BS, N, 4]
+    anchors = anchors.to(batch_cls_head).unsqueeze(0).expand(batch_size, -1, -1)  # [N, 4] -> [BS, N, 4]
     # it has to be raw logits but check anyway to avoid applying sigmoid twice
     if batch_cls_head.min() < 0 or batch_cls_head.max() > 1:
         batch_cls_head = batch_cls_head.sigmoid()
-    
-    # It's much faster to calculate topk once for full batch here rather than doing it inside loop 
+
+    # It's much faster to calculate topk once for full batch here rather than doing it inside loop
     # In TF The same bbox may belong to two different objects
     # select `max_detection_points` scores and corresponding bboxes
-    scores_topk_all, cls_topk_indices_all = torch.topk(batch_cls_head.view(batch_size, -1), k=max_detection_points)
+    scores_topk_all, cls_topk_indices_all = torch.topk(
+        batch_cls_head.view(batch_size, -1), k=max_detection_points
+    )
     indices_all = cls_topk_indices_all / num_classes
     classes_all = cls_topk_indices_all % num_classes
 
@@ -322,32 +328,29 @@ def decode(
     out_classes = torch.zeros((batch_size, max_detection_per_image)).to(batch_cls_head)
 
     for batch in range(batch_size):
-        scores_topk = scores_topk_all[batch] #  , cls_topk_indices_all[batch]
-        classes = classes_all[batch] #cls_topk_indices % num_classes
-        box_topk = box_topk_all[batch] # torch.gather(batch_box_head[batch], 0, indices)
-        anchor_topk = anchors_topk_all[batch]
-        regressed_boxes = regressed_boxes_all[batch] # delta2box(box_topk, anchor_topk)
+        scores_topk = scores_topk_all[batch]  #  , cls_topk_indices_all[batch]
+        classes = classes_all[batch]  # cls_topk_indices % num_classes
+        regressed_boxes = regressed_boxes_all[batch]  # delta2box(box_topk, anchor_topk)
 
         # apply NMS
         nms_idx = batched_nms(regressed_boxes, scores_topk, classes, iou_threshold)
-        nms_idx = nms_idx[:min(len(nms_idx), max_detection_per_image)]
+        nms_idx = nms_idx[: min(len(nms_idx), max_detection_per_image)]
         # select suppressed bboxes
         im_scores = scores_topk[nms_idx]
         im_classes = classes[nms_idx]
         im_bboxes = regressed_boxes[nms_idx]
         im_classes += 1  # back to class idx with background class = 0
 
-        out_scores[batch, :im_scores.size(0)] = im_scores
-        out_classes[batch, :im_classes.size(0)] = im_classes
-        out_boxes[batch, :im_bboxes.size(0)] = im_bboxes
+        out_scores[batch, : im_scores.size(0)] = im_scores
+        out_classes[batch, : im_classes.size(0)] = im_classes
+        out_boxes[batch, : im_bboxes.size(0)] = im_bboxes
         # no need to pad because it's already padded with 0's
-        
 
         ## old way ##
         # get regressed bboxes
         # all_img_bboxes = delta2box(batch_box_head[batch], anchors)
         # if img_shape: # maybe clip
-            # all_img_bboxes = clip_bboxes(all_img_bboxes, img_shape)
+        # all_img_bboxes = clip_bboxes(all_img_bboxes, img_shape)
         # select at most `top_n` bboxes and from them select with score > threshold
         # max_cls_score, max_cls_idx = batch_cls_head[batch].max(1)
         # top_cls_score, top_cls_idx = max_cls_score.topk(top_n)
@@ -356,15 +359,15 @@ def decode(
         # im_scores = max_cls_score[top_cls_idx]
         # im_classes = max_cls_idx[top_cls_idx]
         # im_bboxes = all_img_bboxes[top_cls_idx]
-        
+
         # apply NMS
         # nms_idx = batched_nms(im_bboxes, im_scores, im_classes, iou_threshold)
         # im_scores = im_scores[nms_idx]
         # im_classes = im_classes[nms_idx]
         # im_bboxes = im_bboxes[nms_idx]
-        
+
         # out_scores[batch, :im_scores.size(0)] = im_scores
         # out_classes[batch, :im_classes.size(0)] = im_classes
         # out_boxes[batch, :im_bboxes.size(0)] = im_bboxes
-        
-    return torch.cat([out_boxes, out_scores.unsqueeze(-1), out_classes.unsqueeze(-1)], dim=2)
\ No newline at end of file
+
+    return torch.cat([out_boxes, out_scores.unsqueeze(-1), out_classes.unsqueeze(-1)], dim=2)
diff --git a/pytorch_tools/utils/misc.py b/pytorch_tools/utils/misc.py
index cf1fc85..733a22e 100644
--- a/pytorch_tools/utils/misc.py
+++ b/pytorch_tools/utils/misc.py
@@ -5,10 +5,10 @@
 import random
 import collections
 import numpy as np
+from functools import partial
 import torch.nn as nn
 import torch.nn.functional as F
 import torch.distributed as dist
-from functools import partial
 
 
 def initialize_fn(m):
@@ -27,10 +27,12 @@ def initialize_fn(m):
         nn.init.kaiming_uniform_(m.weight, mode="fan_out", nonlinearity="linear")
         nn.init.constant_(m.bias, 0)
 
+
 def initialize(module):
     for m in module.modules():
         initialize_fn(m)
 
+
 def initialize_iterator(module_iterator):
     for m in module_iterator:
         initialize_fn(m)
@@ -219,6 +221,7 @@ def make_divisible(v, divisor=8):
         new_v += divisor
     return new_v
 
+
 def repeat_channels(conv_weights, new_channels, old_channels=3):
     """Repeat channels to match new number of input channels
     Args:
@@ -228,5 +231,5 @@ def repeat_channels(conv_weights, new_channels, old_channels=3):
     """
     rep_times = math.ceil(new_channels / old_channels)
     new_weights = conv_weights.repeat(1, rep_times, 1, 1)[:, :new_channels, :, :]
-    new_weights *= old_channels / new_channels # to keep the same output amplitude
-    return new_weights
\ No newline at end of file
+    new_weights *= old_channels / new_channels  # to keep the same output amplitude
+    return new_weights
diff --git a/tests/detection_models/test_det_models.py b/tests/detection_models/test_det_models.py
index 62ebb13..0ab1ff2 100644
--- a/tests/detection_models/test_det_models.py
+++ b/tests/detection_models/test_det_models.py
@@ -51,7 +51,7 @@ def test_coco_pretrain(arch):
         im = np.array(im.resize((inp_size, inp_size)))
         im_t = tensor_from_rgb_image(preprocess_fn(im)).unsqueeze(0).float().cuda()
         boxes_scores_classes = m.predict(im_t)
-        # check that most confident bbox is close to correct class. The reason for such strange test is 
+        # check that most confident bbox is close to correct class. The reason for such strange test is
         # because in different models class mappings are shifted by +- 1
         assert (boxes_scores_classes[0, 0, 5] - im_cls) < 2
 
@@ -61,6 +61,7 @@ def test_pretrain_custom_num_classes(arch):
     m = pt_det.__dict__[arch](pretrained="coco", num_classes=80).eval().cuda()
     _test_forward(m)
 
+
 @pytest.mark.parametrize("arch", MODEL_NAMES[:2])
 def test_encoder_frozenabn(arch):
     m = pt_det.__dict__[arch](encoder_norm_layer="frozenabn").eval().cuda()
diff --git a/tests/losses/test_losses.py b/tests/losses/test_losses.py
index cf3090e..2f7a741 100644
--- a/tests/losses/test_losses.py
+++ b/tests/losses/test_losses.py
@@ -52,9 +52,7 @@ def test_focal_loss_fn_basic():
 
 @pytest.mark.parametrize("reduction", ["sum", "mean", "none"])
 def test_focal_loss_fn_reduction(reduction):
-    torch_ce = F.binary_cross_entropy_with_logits(
-        INP_BINARY, TARGET_BINARY.float(), reduction=reduction
-    )
+    torch_ce = F.binary_cross_entropy_with_logits(INP_BINARY, TARGET_BINARY.float(), reduction=reduction)
     my_ce = pt_F.focal_loss_with_logits(INP_BINARY, TARGET_BINARY, alpha=0.5, gamma=0, reduction=reduction)
     assert torch.allclose(torch_ce, my_ce * 2)
 
@@ -108,6 +106,7 @@ def test_focal_loss():
     fl_i = losses.FocalLoss(mode="binary", reduction="sum", ignore_label=-100)(INP_IMG_BINARY, y_true)
     assert torch.allclose(fl.sum() - loss_diff, fl_i)
 
+
 @pytest.mark.parametrize(
     ["y_true", "y_pred", "expected"],
     [
@@ -333,9 +332,7 @@ def test_binary_cross_entropy(reduction):
     assert torch.allclose(torch_ce, my_ce)
 
     # test for images
-    torch_ce = F.binary_cross_entropy_with_logits(
-        INP_IMG_BINARY, TARGET_IMG_BINARY, reduction=reduction
-    )
+    torch_ce = F.binary_cross_entropy_with_logits(INP_IMG_BINARY, TARGET_IMG_BINARY, reduction=reduction)
     my_ce = my_ce_loss(INP_IMG_BINARY, TARGET_IMG_BINARY)
     assert torch.allclose(torch_ce, my_ce)
 
@@ -391,4 +388,4 @@ def test_binary_hinge():
 @pytest.mark.parametrize("reduction", ["sum", "mean", "none"])
 def test_smoothl1(reduction):
     loss_my = losses.SmoothL1Loss(delta=1, reduction=reduction)(INP, TARGET_MULTILABEL)
-    loss_torch = F.smooth_l1_loss(INP, TARGET_MULTILABEL, reduction=reduction)
\ No newline at end of file
+    loss_torch = F.smooth_l1_loss(INP, TARGET_MULTILABEL, reduction=reduction)
diff --git a/tests/models/test_models.py b/tests/models/test_models.py
index d5fb396..0042a85 100644
--- a/tests/models/test_models.py
+++ b/tests/models/test_models.py
@@ -23,7 +23,14 @@
 HRNET_NAMES = [name for name in ALL_MODEL_NAMES if "hrnet" in name]
 
 # test only part of the models
-TEST_MODEL_NAMES = DENSENET_NAMES[:1] + EFFNET_NAMES[:1] + VGG_NAMES[:1] + RESNET_NAMES[:1] + TRESNET_NAMES[:1] + HRNET_NAMES[:1]
+TEST_MODEL_NAMES = (
+    DENSENET_NAMES[:1]
+    + EFFNET_NAMES[:1]
+    + VGG_NAMES[:1]
+    + RESNET_NAMES[:1]
+    + TRESNET_NAMES[:1]
+    + HRNET_NAMES[:1]
+)
 # TEST_MODEL_NAMES = HRNET_NAMES[:1]
 INP = torch.ones(2, 3, 128, 128)
 
@@ -52,6 +59,7 @@ def test_custom_in_channels(arch):
     with torch.no_grad():
         m(torch.ones(2, 5, 128, 128))
 
+
 @pytest.mark.parametrize("arch", EFFNET_NAMES[:2] + RESNET_NAMES[:2])
 def test_pretrained_custom_in_channels(arch):
     m = models.__dict__[arch](in_channels=5, pretrained="imagenet")
@@ -82,11 +90,13 @@ def test_dilation(arch, output_stride):
     W, H = INP.shape[-2:]
     assert res.shape[-2:] == (W // output_stride, H // output_stride)
 
+
 @pytest.mark.parametrize("arch", EFFNET_NAMES[:2] + RESNET_NAMES[:2])
 def test_drop_connect(arch):
     m = models.__dict__[arch](drop_connect_rate=0.2)
     _test_forward(m)
 
+
 NUM_PARAMS = {
     "tresnetm": 31389032,
     "tresnetl": 55989256,
@@ -96,13 +106,16 @@ def test_drop_connect(arch):
     "efficientnet_b2": 9109994,
     "efficientnet_b3": 12233232,
 }
-@pytest.mark.parametrize('name_num_params', zip(NUM_PARAMS.items()))
+
+
+@pytest.mark.parametrize("name_num_params", zip(NUM_PARAMS.items()))
 def test_num_parameters(name_num_params):
     name, num_params = name_num_params[0]
     m = models.__dict__[name]()
     assert pt.utils.misc.count_parameters(m)[0] == num_params
 
-@pytest.mark.parametrize('stem_type', ["", "deep", "space2depth"])
+
+@pytest.mark.parametrize("stem_type", ["", "deep", "space2depth"])
 def test_resnet_stem_type(stem_type):
     m = models.resnet50(stem_type=stem_type)
-    _test_forward(m)
\ No newline at end of file
+    _test_forward(m)
diff --git a/tests/models/test_weights.py b/tests/models/test_weights.py
index c22c173..c68cd72 100644
--- a/tests/models/test_weights.py
+++ b/tests/models/test_weights.py
@@ -55,6 +55,7 @@ def test_imagenet_pretrain(arch):
         pred_cls = m(im).argmax()
         assert pred_cls == im_cls
 
+
 # test that output mean for fixed input is the same
 MODEL_NAMES2 = [
     "resnet34",
@@ -68,6 +69,7 @@ def test_imagenet_pretrain(arch):
     "efficientnet_b0": 0.0070,
 }
 
+
 @pytest.mark.parametrize("arch", MODEL_NAMES2)
 def test_output_mean(arch):
     m = models.__dict__[arch](pretrained="imagenet")
diff --git a/tests/modules/test_modules.py b/tests/modules/test_modules.py
index 969adc0..1be5837 100644
--- a/tests/modules/test_modules.py
+++ b/tests/modules/test_modules.py
@@ -13,12 +13,14 @@ def test_activations_init(activation):
     res = act(inp)
     assert res.mean()
 
+
 def test_frozen_abn():
     l = modules.bn_from_name("frozen_abn")(10)
     assert list(l.parameters()) == []
     l = modules.ABN(10, frozen=True)
     assert list(l.parameters()) == []
 
+
 # need to test and resnet and vgg because in resnet there are no Convs with bias
 # and in VGG there are no Convs without bias
 @pytest.mark.parametrize("norm_layer", ["abn", "agn"])
diff --git a/tests/segmentation_models/test_segm_models.py b/tests/segmentation_models/test_segm_models.py
index d454815..cb6378d 100644
--- a/tests/segmentation_models/test_segm_models.py
+++ b/tests/segmentation_models/test_segm_models.py
@@ -7,12 +7,13 @@
 
 INP = torch.ones(2, 3, 64, 64)
 ENCODERS = ["resnet34", "se_resnet50", "efficientnet_b1", "densenet121"]
-SEGM_ARCHS = [pt_sm.Unet, pt_sm.Linknet, pt_sm.DeepLabV3, pt_sm.SegmentationFPN, pt_sm.SegmentationBiFPN]
+SEGM_ARCHS = [pt_sm.Unet, pt_sm.Linknet, pt_sm.DeepLabV3, pt_sm.SegmentationFPN]  # pt_sm.SegmentationBiFPN
 
 # this lines are usefull for quick tests
 # ENCODERS = ["se_resnet50"]
 # SEGM_ARCHS = [pt_sm.SegmentationFPN, pt_sm.SegmentationFPN]
 
+
 def _test_forward(model):
     with torch.no_grad():
         return model(INP)
@@ -47,21 +48,24 @@ def test_num_classes(encoder_name, model_class):
     out = _test_forward(m)
     assert out.size(1) == 5
 
+
 @pytest.mark.parametrize("encoder_name", ENCODERS)
 @pytest.mark.parametrize("model_class", SEGM_ARCHS)
 def test_drop_rate(encoder_name, model_class):
     m = model_class(encoder_name=encoder_name, drop_rate=0.2)
     _test_forward(m)
 
+
 @pytest.mark.parametrize("encoder_name", ENCODERS)
 @pytest.mark.parametrize("model_class", [pt_sm.DeepLabV3])  # pt_sm.Unet, pt_sm.Linknet
 @pytest.mark.parametrize("output_stride", [32, 16, 8])
 def test_dilation(encoder_name, model_class, output_stride):
     if output_stride == 8 and model_class != pt_sm.DeepLabV3:
-        return None # OS=8 only supported for Deeplab
+        return None  # OS=8 only supported for Deeplab
     m = model_class(encoder_name=encoder_name, output_stride=output_stride)
     _test_forward(m)
 
+
 @pytest.mark.parametrize("model_class", [pt_sm.DeepLabV3, pt_sm.SegmentationFPN])
 def test_deeplab_last_upsample(model_class):
     m = model_class(last_upsample=True)
@@ -74,7 +78,8 @@ def test_deeplab_last_upsample(model_class):
     # should be 4 times smaller
     assert tuple(out.shape[-2:]) == (W // 4, H // 4)
 
+
 @pytest.mark.parametrize("merge_policy", ["add", "cat"])
 def test_merge_policy(merge_policy):
     m = pt_sm.SegmentationFPN(merge_policy=merge_policy)
-    _test_forward(m)
\ No newline at end of file
+    _test_forward(m)
diff --git a/tests/utils/test_utils.py b/tests/utils/test_utils.py
index 13b4f23..e3257f4 100644
--- a/tests/utils/test_utils.py
+++ b/tests/utils/test_utils.py
@@ -2,18 +2,23 @@
 import pytest
 import pytorch_tools as pt
 
+
 def random_boxes(mean_box, stdev, N):
     return torch.rand(N, 4) * stdev + torch.tensor(mean_box, dtype=torch.float)
 
+
+# fmt: off
 DEVICE_DTYPE =  [
     ("cpu", torch.float), 
     ("cuda", torch.float), 
     ("cuda", torch.half)
 ]
+# fmt: on
 # check that it works for all combinations of dtype and device
 @pytest.mark.parametrize("device_dtype", DEVICE_DTYPE)
 def test_clip_bboxes(device_dtype):
     device, dtype = device_dtype
+    # fmt: off
     bboxes = torch.tensor(
         [
             [-5, -10, 50, 100],
@@ -30,6 +35,7 @@ def test_clip_bboxes(device_dtype):
         device=device,
         dtype=dtype,
     )
+    # fmt: on
     size = (60, 40)
     # test single bbox clip
     res1 = pt.utils.box.clip_bboxes(bboxes, size)
@@ -55,9 +61,11 @@ def test_clip_bboxes(device_dtype):
     res5 = jit_clip(batch_bboxes.clone(), batch_sizes)
     assert torch.allclose(res5, batch_expected)
 
+
 @pytest.mark.parametrize("device_dtype", DEVICE_DTYPE)
 def test_delta2box(device_dtype):
     device, dtype = device_dtype
+    # fmt: off
     anchors = torch.tensor(
         [
             [ 0.,  0.,  1.,  1.],
@@ -84,12 +92,13 @@ def test_delta2box(device_dtype):
             [0.0000, 0.0000, 1.0000, 1.0000],
             [0.1409, 0.1409, 2.8591, 2.8591],
             [-3.1945, 0.3161, 4.1945, 0.6839],
-            [5.0000, 5.0000, 5.0000, 5.0000]
+            [5.0000, 5.0000, 5.0000, 5.0000],
         ],
         device=device,
         dtype=dtype,
     )
-    res1 =  pt.utils.box.delta2box(deltas, anchors)
+    # fmt: on
+    res1 = pt.utils.box.delta2box(deltas, anchors)
     assert torch.allclose(res1, expected_res, atol=3e-4)
 
     BS = 4
@@ -97,8 +106,8 @@ def test_delta2box(device_dtype):
     batch_deltas = deltas.unsqueeze(0).expand(BS, -1, -1)
     batch_expected = expected_res.unsqueeze(0).expand(BS, -1, -1)
 
-    # test applying to batch 
-    res2 =  pt.utils.box.delta2box(batch_deltas.clone(), batch_anchors)
+    # test applying to batch
+    res2 = pt.utils.box.delta2box(batch_deltas.clone(), batch_anchors)
     assert torch.allclose(res2, batch_expected, atol=3e-4)
 
     # check that function is JIT script friendly
@@ -106,6 +115,7 @@ def test_delta2box(device_dtype):
     res3 = jit_func(batch_deltas.clone(), batch_anchors)
     assert torch.allclose(res3, batch_expected, atol=3e-4)
 
+
 @pytest.mark.parametrize("device_dtype", DEVICE_DTYPE)
 def test_box2delta(device_dtype):
     ## this test only checks that encoding and decoding  gives the same result
@@ -114,12 +124,12 @@ def test_box2delta(device_dtype):
     anchors = random_boxes([10, 10, 20, 20], 10, 10).to(device).to(dtype)
     deltas = pt.utils.box.box2delta(boxes, anchors)
     boxes_reconstructed = pt.utils.box.delta2box(deltas, anchors)
-    atol = 2e-2 if dtype == torch.half else 1e-6 # for fp16 sometimes error is large 
-    assert torch.allclose(boxes, boxes_reconstructed, atol=atol) 
+    atol = 2e-2 if dtype == torch.half else 1e-6  # for fp16 sometimes error is large
+    assert torch.allclose(boxes, boxes_reconstructed, atol=atol)
 
     # check that it's jit friendly
     jit_box2delta = torch.jit.script(pt.utils.box.box2delta)
     jit_delta2box = torch.jit.script(pt.utils.box.delta2box)
     deltas2 = jit_box2delta(boxes, anchors)
     boxes_reconstructed2 = jit_delta2box(deltas2, anchors)
-    assert torch.allclose(boxes, boxes_reconstructed2,  atol=atol)
\ No newline at end of file
+    assert torch.allclose(boxes, boxes_reconstructed2, atol=atol)