release ssseg v1.5.7

Author: CharlesPikachu

ssseg/__init__.py

@@ -1,5 +1,5 @@
 '''version'''
-__version__ = '1.5.6'
+__version__ = '1.5.7'
 '''author'''
 __author__ = 'Zhenchao Jin'
 '''title'''

ssseg/modules/datasets/base.py

@@ -48,7 +48,7 @@ def __getitem__(self, index):
     '''len'''
     def __len__(self):
         return len(self.imageids) * self.repeat_times
-    '''read sample_meta'''
+    '''read'''
     def read(self, imagepath, annpath=None):
         # read image
         image = cv2.imread(imagepath)

ssseg/modules/datasets/cityscapes.py

@@ -58,7 +58,7 @@ def __getitem__(self, index):
         sample_meta = self.synctransforms(sample_meta)
         # return
         return sample_meta
-    '''format results for test set of Cityscapes'''
+    '''formatresults'''
     @staticmethod
     def formatresults(results, filenames, to_label_id=True, savedir='results'):
         assert len(filenames) == len(results)

ssseg/modules/datasets/pipelines/evaluation.py

@@ -18,7 +18,7 @@ def __init__(self, seg_preds, seg_targets, num_classes, ignore_index=-1, nan_to_
         self.all_metric_results = self.totalareatometrics(
             total_area_intersect=total_area_intersect, total_area_union=total_area_union, total_area_pred_label=total_area_pred_label, total_area_label=total_area_label, nan_to_num=nan_to_num, beta=beta,
         )
-    '''calculate total intersection and union'''
+    '''totalintersectandunion'''
     @staticmethod
     def totalintersectandunion(results, gt_seg_maps, num_classes, ignore_index=-1):
         total_area_intersect = torch.zeros((num_classes, ), dtype=torch.float64)
@@ -32,7 +32,7 @@ def totalintersectandunion(results, gt_seg_maps, num_classes, ignore_index=-1):
             total_area_pred_label += area_pred_label
             total_area_label += area_label
         return total_area_intersect, total_area_union, total_area_pred_label, total_area_label
-    '''calculate intersection and union'''
+    '''intersectandunion'''
     @staticmethod
     def intersectandunion(pred_label, label, num_classes, ignore_index=-1):
         # convert to torch.array
@@ -50,7 +50,7 @@ def intersectandunion(pred_label, label, num_classes, ignore_index=-1):
         area_union = area_pred_label + area_label - area_intersect
         # return
         return area_intersect, area_union, area_pred_label, area_label
-    '''calculate evaluation metrics'''
+    '''totalareatometrics'''
     @staticmethod
     def totalareatometrics(total_area_intersect, total_area_union, total_area_pred_label, total_area_label, nan_to_num=None, beta=1):
         # all metrics
@@ -80,7 +80,7 @@ def totalareatometrics(total_area_intersect, total_area_union, total_area_pred_l
         all_metric_results['mdice'] = np.nanmean(all_metric_results['dice'])
         all_metric_results['mfscore'] = np.nanmean(all_metric_results['fscore'])
         return all_metric_results
-    '''calcuate the f-score value'''
+    '''calcuatefscore'''
     @staticmethod
     def calcuatefscore(precision, recall, beta=1):
         score = (1 + beta**2) * (precision * recall) / ((beta**2 * precision) + recall)

ssseg/modules/datasets/pipelines/transforms.py

@@ -473,11 +473,11 @@ def __call__(self, sample_meta):
         sample_meta['image'] = self.hue(sample_meta['image'])
         if mode == 0: sample_meta['image'] = self.contrast(sample_meta['image'])
         return sample_meta
-    '''brightness distortion'''
+    '''brightness'''
     def brightness(self, image):
         if not np.random.randint(2): return image
         return self.convert(image, beta=np.random.uniform(-self.brightness_delta, self.brightness_delta))
-    '''contrast distortion'''
+    '''contrast'''
     def contrast(self, image):
         if not np.random.randint(2): return image
         return self.convert(image, alpha=np.random.uniform(self.contrast_lower, self.contrast_upper))
@@ -487,21 +487,21 @@ def rgb2hsv(self, image):
     '''hsv2rgb'''
     def hsv2rgb(self, image):
         return cv2.cvtColor(image, cv2.COLOR_HSV2RGB)
-    '''saturation distortion'''
+    '''saturation'''
     def saturation(self, image):
         if not np.random.randint(2): return image
         image = self.rgb2hsv(image)
         image[..., 1] = self.convert(image[..., 1], alpha=np.random.uniform(self.saturation_lower, self.saturation_upper))
         image = self.hsv2rgb(image)
         return image
-    '''hue distortion'''
+    '''hue'''
     def hue(self, image):
         if not np.random.randint(2): return image
         image = self.rgb2hsv(image)
         image[..., 0] = (image[..., 0].astype(int) + np.random.randint(-self.hue_delta, self.hue_delta)) % 180
         image = self.hsv2rgb(image)
         return image
-    '''multiple with alpha and add beat with clip'''
+    '''convert'''
     def convert(self, image, alpha=1, beta=0):
         image = image.astype(np.float32) * alpha + beta
         image = np.clip(image, 0, 255)

ssseg/modules/models/backbones/bricks/__init__.py

@@ -12,7 +12,7 @@
     Scale, L2Norm, makedivisible, truncnormal
 )
 from .transformer import (
-    FFN, MultiheadAttention, nchwtonlc, nlctonchw, PatchEmbed, PatchMerging, AdaptivePadding, PositionEmbeddingSine
+    FFN, MultiheadAttention, PatchEmbed, PatchMerging, AdaptivePadding, PositionEmbeddingSine, nchwtonlc, nlctonchw, nlc2nchw2nlc, nchw2nlc2nchw
 )
 from .convolution import (
     DynamicConv2d, AdptivePaddingConv2d, SqueezeExcitationConv2d, DepthwiseSeparableConv2d, InvertedResidual, InvertedResidualV3

ssseg/modules/models/backbones/bricks/convolution/apconv.py

@@ -7,21 +7,16 @@
 import math
 import torch.nn as nn
 import torch.nn.functional as F
+from ..activation import BuildActivation
 from ..normalization import BuildNormalization
 
 
 '''AdptivePaddingConv2d'''
 class AdptivePaddingConv2d(nn.Conv2d):
     def __init__(self, in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, norm_cfg=None, act_cfg=None):
         super(AdptivePaddingConv2d, self).__init__(
-            in_channels=in_channels, 
-            out_channels=out_channels, 
-            kernel_size=kernel_size, 
-            stride=stride, 
-            padding=0,
-            dilation=dilation, 
-            groups=groups, 
-            bias=bias
+            in_channels=in_channels, out_channels=out_channels, kernel_size=kernel_size, stride=stride, padding=0,
+            dilation=dilation, groups=groups, bias=bias
         )
         if norm_cfg is not None: 
             self.norm = BuildNormalization(placeholder=out_channels, norm_cfg=norm_cfg)

ssseg/modules/models/backbones/bricks/convolution/dsconv.py

@@ -4,7 +4,6 @@
 Author:
     Zhenchao Jin
 '''
-import torch
 import torch.nn as nn
 from ..activation import BuildActivation
 from ..normalization import BuildNormalization

ssseg/modules/models/backbones/bricks/convolution/dyconv.py

@@ -74,23 +74,11 @@ def forward(self, x):
         if self.bias is not None:
             aggregate_bias = torch.mm(softmax_attention, self.bias).view(-1)
             output = F.conv2d(
-                input=x,
-                weight=aggregate_weight,
-                bias=aggregate_bias,
-                stride=self.stride,
-                padding=self.padding,
-                dilation=self.dilation,
-                groups=self.groups * batch_size,
+                input=x, weight=aggregate_weight, bias=aggregate_bias, stride=self.stride, padding=self.padding, dilation=self.dilation, groups=self.groups * batch_size,
             )
         else:
             output = F.conv2d(
-                input=x,
-                weight=aggregate_weight,
-                bias=None,
-                stride=self.stride,
-                padding=self.padding,
-                dilation=self.dilation,
-                groups=self.groups * batch_size,
+                input=x, weight=aggregate_weight, bias=None, stride=self.stride, padding=self.padding, dilation=self.dilation, groups=self.groups * batch_size,
             )
         output = output.view(batch_size, self.out_channels, output.size(-2), output.size(-1))
         if hasattr(self, 'norm'): output = self.norm(output)

ssseg/modules/models/backbones/bricks/normalization/layernorm2d.py

@@ -4,7 +4,6 @@
 Author:
     Zhenchao Jin
 '''
-import torch
 import torch.nn as nn
 import torch.nn.functional as F
 

ssseg/modules/models/backbones/bricks/transformer/__init__.py

@@ -3,4 +3,4 @@
 from .mha import MultiheadAttention
 from .pe import PositionEmbeddingSine
 from .embed import PatchEmbed, PatchMerging, AdaptivePadding
-from .misc import nchwtonlc, nlctonchw, nlc2nchw2nlc, nchw2nlc2nchw
+from .shape import nchwtonlc, nlctonchw, nlc2nchw2nlc, nchw2nlc2nchw

ssseg/modules/models/backbones/bricks/transformer/misc.py renamed to ssseg/modules/models/backbones/bricks/transformer/shape.py

@@ -7,7 +7,6 @@
 import os
 import torch
 import torch.nn as nn
-import torch.nn.functional as F
 import torch.utils.model_zoo as model_zoo
 from functools import partial
 from .bricks.dropout.droppath import DropPath

ssseg/modules/models/backbones/convnext.py

@@ -53,18 +53,18 @@ def forward(self, x):
                     y += self.fuse_layers[i][j](x[j])
             x_fuse.append(self.relu(y))
         return x_fuse
-    '''check branches'''
+    '''checkbranches'''
     def checkbranches(self, num_branches, num_blocks, in_channels, num_channels):
         assert num_branches == len(num_blocks), 'num_branches should be equal to len(num_blocks)'
         assert num_branches == len(num_channels), 'num_branches should be equal to len(num_channels)'
         assert num_branches == len(in_channels), 'num_branches should be equal to len(in_channels)'
-    '''make branches'''
+    '''makebranches'''
     def makebranches(self, num_branches, block, num_blocks, num_channels, norm_cfg=None, act_cfg=None):
         branches = []
         for i in range(num_branches):
             branches.append(self.makebranch(i, block, num_blocks, num_channels, norm_cfg=norm_cfg, act_cfg=act_cfg))
         return nn.ModuleList(branches)
-    '''make one branch'''
+    '''makebranch'''
     def makebranch(self, branch_index, block, num_blocks, num_channels, stride=1, norm_cfg=None, act_cfg=None):
         downsample = None
         if stride != 1 or self.in_channels[branch_index] != num_channels[branch_index] * block.expansion:
@@ -78,7 +78,7 @@ def makebranch(self, branch_index, block, num_blocks, num_channels, stride=1, no
         for i in range(1, num_blocks[branch_index]):
             layers.append(block(self.in_channels[branch_index], num_channels[branch_index], norm_cfg=norm_cfg, act_cfg=act_cfg))
         return nn.Sequential(*layers)
-    '''make fuse layer'''
+    '''makefuselayers'''
     def makefuselayers(self, norm_cfg=None, act_cfg=None):
         if self.num_branches == 1: return None
         num_branches = self.num_branches
@@ -243,7 +243,7 @@ def forward(self, x):
         out = torch.cat([F.interpolate(y, size=(h, w), mode='bilinear', align_corners=False) for y in y_list], dim=1)
         outs = [out]
         return tuple(outs)
-    '''make stage'''
+    '''makestage'''
     def makestage(self, layer_config, in_channels, multiscale_output=True, norm_cfg=None, act_cfg=None):
         num_modules = layer_config['num_modules']
         num_branches = layer_config['num_branches']
@@ -258,7 +258,7 @@ def makestage(self, layer_config, in_channels, multiscale_output=True, norm_cfg=
                 reset_multiscale_output = True
             hr_modules.append(HRModule(num_branches, block, num_blocks, in_channels, num_channels, reset_multiscale_output, norm_cfg, act_cfg))
         return nn.Sequential(*hr_modules), in_channels
-    '''make layer'''
+    '''makelayer'''
     def makelayer(self, block, inplanes, planes, num_blocks, stride=1, norm_cfg=None, act_cfg=None):
         downsample = None
         if stride != 1 or inplanes != planes * block.expansion:
@@ -276,7 +276,7 @@ def makelayer(self, block, inplanes, planes, num_blocks, stride=1, norm_cfg=None
                 block(inplanes, planes, norm_cfg=norm_cfg, act_cfg=act_cfg)
             )
         return nn.Sequential(*layers)
-    '''make transition layer'''
+    '''maketransitionlayer'''
     def maketransitionlayer(self, num_channels_pre_layer, num_channels_cur_layer, norm_cfg=None, act_cfg=None):
         num_branches_cur = len(num_channels_cur_layer)
         num_branches_pre = len(num_channels_pre_layer)

ssseg/modules/models/backbones/hrnet.py

@@ -171,7 +171,7 @@ def loadpretrainedweights(self, structure_type='mobilenetv3_small', pretrained_m
                 key = '.'.join(key.split('.')[1:])
                 state_dict[key] = value
         self.load_state_dict(state_dict, strict=False)
-    '''make layers'''
+    '''makelayers'''
     def makelayers(self, in_channels, arch_type, reduction_factor, outstride, norm_cfg=None, act_cfg=None):
         layers, act_cfg_default = [], act_cfg.copy()
         # build the first layer

ssseg/modules/models/backbones/mobilenet.py

@@ -166,7 +166,7 @@ def __init__(self, structure_type, groups=1, base_width=4, radix=2, reduction_fa
                 structure_type=structure_type, pretrained_model_path=pretrained_model_path, default_model_urls=DEFAULT_MODEL_URLS
             )
             self.load_state_dict(state_dict, strict=False)
-    '''make res layer'''
+    '''makelayer'''
     def makelayer(self, block, inplanes, planes, num_blocks, stride=1, dilation=1, contract_dilation=True, use_avg_for_downsample=False, norm_cfg=None, act_cfg=None):
         downsample = None
         dilations = [dilation] * num_blocks

ssseg/modules/models/backbones/resnest.py

@@ -171,7 +171,7 @@ def __init__(self, structure_type, in_channels=3, base_channels=64, stem_channel
                 structure_type=structure_type, pretrained_model_path=pretrained_model_path, default_model_urls=DEFAULT_MODEL_URLS
             )
             self.load_state_dict(state_dict, strict=False)
-    '''make res layer'''
+    '''makelayer'''
     def makelayer(self, block, inplanes, planes, num_blocks, stride=1, dilation=1, contract_dilation=True, use_avg_for_downsample=False, norm_cfg=None, act_cfg=None):
         downsample = None
         dilations = [dilation] * num_blocks

ssseg/modules/models/backbones/resnet.py

@@ -380,7 +380,7 @@ def loadpretrainedweights(self, structure_type='swin_tiny_patch4_window7_224', p
                 state_dict[table_key] = table_pretrained_resized.view(nH2, L2).permute(1, 0).contiguous()
         # load state_dict
         self.load_state_dict(state_dict, strict=False)
-    '''swin convert'''
+    '''swinconvert'''
     @staticmethod
     def swinconvert(ckpt):
         new_ckpt = OrderedDict()

ssseg/modules/models/backbones/swin.py

@@ -252,7 +252,7 @@ def loadpretrainedweights(self, structure_type='pcpvt_small', pretrained_model_p
         state_dict = self.twinsconvert(structure_type, state_dict)
         # load state_dict
         self.load_state_dict(state_dict, strict=False)
-    '''twins convert'''
+    '''twinsconvert'''
     @staticmethod
     def twinsconvert(structure_type, ckpt):
         new_ckpt = OrderedDict()

ssseg/modules/models/backbones/twins.py

@@ -170,7 +170,7 @@ def forward(self, x):
             x = self.decoder[i](enc_outs[i], x)
             dec_outs.append(x)
         return dec_outs
-    '''check input divisible'''
+    '''checkinputdivisible'''
     def checkinputdivisible(self, x):
         h, w = x.shape[-2:]
         whole_downsample_rate = 1

ssseg/modules/models/backbones/unet.py

@@ -148,7 +148,7 @@ def loadpretrainedweights(self, structure_type='jx_vit_large_p16_384', pretraine
                 pos_size = int(math.sqrt(state_dict['pos_embed'].shape[1] - 1))
                 state_dict['pos_embed'] = self.resizeposembed(state_dict['pos_embed'], (h // self.patch_size, w // self.patch_size), (pos_size, pos_size), self.interpolate_mode)
         self.load_state_dict(state_dict, strict=False)
-    '''vit convert'''
+    '''vitconvert'''
     @staticmethod
     def vitconvert(ckpt):
         from collections import OrderedDict
@@ -173,7 +173,7 @@ def vitconvert(ckpt):
                 new_k = k
             new_ckpt[new_k] = v
         return new_ckpt
-    '''positiong embeding method'''
+    '''posembeding'''
     def posembeding(self, patched_img, hw_shape, pos_embed):
         assert patched_img.ndim == 3 and pos_embed.ndim == 3, 'the shapes of patched_img and pos_embed must be [B, L, C]'
         x_len, pos_len = patched_img.shape[1], pos_embed.shape[1]
@@ -185,7 +185,7 @@ def posembeding(self, patched_img, hw_shape, pos_embed):
                 raise ValueError('Unexpected shape of pos_embed, got {}.'.format(pos_embed.shape))
             pos_embed = self.resizeposembed(pos_embed, hw_shape, (pos_h, pos_w), self.interpolate_mode)
         return self.drop_after_pos(patched_img + pos_embed)
-    '''resize pos_embed weights'''
+    '''resizeposembed'''
     @staticmethod
     def resizeposembed(pos_embed, input_shpae, pos_shape, mode):
         assert pos_embed.ndim == 3, 'shape of pos_embed must be [B, L, C]'

ssseg/modules/models/backbones/vit.py

@@ -11,7 +11,7 @@
 from ...backbones import BuildNormalization
 
 
-'''Asymmetric Fusion Non-local Block (AFNB)'''
+'''AFNBlock'''
 class AFNBlock(nn.Module):
     def __init__(self, low_in_channels, high_in_channels, transform_channels, out_channels, query_scales, key_pool_scales, norm_cfg=None, act_cfg=None):
         super(AFNBlock, self).__init__()

ssseg/modules/models/segmentors/annnet/afnblock.py

@@ -11,7 +11,7 @@
 from ...backbones import BuildActivation, BuildNormalization
 
 
-'''Asymmetric Pyramid Non-local Block (APNB)'''
+'''APNBlock'''
 class APNBlock(nn.Module):
     def __init__(self, in_channels, transform_channels, out_channels, query_scales, key_pool_scales, norm_cfg=None, act_cfg=None):
         super(APNBlock, self).__init__()

ssseg/modules/models/segmentors/annnet/apnblock.py

@@ -8,7 +8,7 @@
 import torch.nn as nn
 
 
-'''Pyramid Pooling Module (Concat only)'''
+'''PPMConcat'''
 class PPMConcat(nn.Module):
     def __init__(self, pool_scales):
         super(PPMConcat, self).__init__()

ssseg/modules/models/segmentors/annnet/ppm.py

@@ -72,7 +72,7 @@ def forward(self, query_feats, key_feats):
         if self.out_project is not None:
             context = self.out_project(context)
         return context
-    '''build project'''
+    '''buildproject'''
     def buildproject(self, in_channels, out_channels, num_convs, use_norm, norm_cfg, act_cfg):
         if use_norm:
             convs = [nn.Sequential(

ssseg/modules/models/segmentors/base/selfattention.py

@@ -43,7 +43,7 @@ def forward(self, x):
             bases = F.normalize(bases, dim=1, p=2)
             self.bases = (1 - self.momentum) * self.bases + self.momentum * bases
         return feats_recon
-    '''reduce mean when distributed training'''
+    '''reducemean'''
     def reducemean(self, tensor):
         if not (dist.is_available() and dist.is_initialized()):
             return tensor

ssseg/modules/models/segmentors/emanet/ema.py

@@ -5,7 +5,6 @@
     Zhenchao Jin
 '''
 import copy
-import torch
 import torch.nn as nn
 import torch.nn.functional as F
 from .encoding import Encoding

ssseg/modules/models/segmentors/encnet/contextencoding.py

@@ -80,7 +80,7 @@ def forward(self, data_meta):
         else:
             ssseg_outputs = SSSegOutputStructure(mode=self.mode, seg_logits=seg_logits)
         return ssseg_outputs
-    '''convert to onehot labels'''
+    '''onehot'''
     def onehot(self, labels, num_classes):
         batch_size = labels.size(0)
         labels_onehot = labels.new_zeros((batch_size, num_classes))