In this tutorial, we demo

How to do inference with MMSeg trained weight
How to train on your own dataset and visualize the results.

Install MMSegmentation

This step may take several minutes.

We use PyTorch 1.5.0 and CUDA 10.1 for this tutorial. You may install other versions by change the version number in pip install command.

# Check nvcc version
!nvcc -V
# Check GCC version
!gcc --version

nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2019 NVIDIA Corporation
Built on Sun_Jul_28_19:07:16_PDT_2019
Cuda compilation tools, release 10.1, V10.1.243
gcc (Ubuntu 7.5.0-3ubuntu1~16.04) 7.5.0
Copyright (C) 2017 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

# # Install PyTorch
# !pip install -U torch==1.5.0+cu101 torchvision==0.6.0+cu101 -f https://download.pytorch.org/whl/torch_stable.html
# # Install MMCV
# !pip install mmcv-full==latest+torch1.5.0+cu101 -f https://download.openmmlab.com/mmcv/dist/index.html

# !rm -rf mmsegmentation
# !git clone https://github.com/open-mmlab/mmsegmentation.git 
# %cd mmsegmentation
# !pip install -e .

# Check Pytorch installation
import torch, torchvision
import os.path as osp
print(torch.__version__, torch.cuda.is_available())

# Check MMSegmentation installation
import mmseg
print(mmseg.__version__)

1.7.0 True
0.19.0

torch.cuda.empty_cache()

Run Inference with MMSeg trained weight

# !mkdir checkpoints
# !wget https://download.openmmlab.com/mmsegmentation/v0.5/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth -P checkpoints

from mmseg.apis import inference_segmentor, init_segmentor, show_result_pyplot
from mmseg.core.evaluation import get_palette

config_file = '/home/ubuntu/sharedData/swp/dlLabSwp/favourite/swpFastTest/mmsegmentation/configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py'
checkpoint_file = 'checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'

# build the model from a config file and a checkpoint file
# model = init_segmentor(config_file, checkpoint_file, device='cuda:0')

# test a single image
img = '/home/ubuntu/sharedData/swp/dlLabSwp/favourite/swpFastTest/mmsegmentation/demo/demo.png'
# result = inference_segmentor(model, img)

# show the results
# show_result_pyplot(model, img, result, get_palette('cityscapes'))

Train a semantic segmentation model on a new dataset

To train on a customized dataset, the following steps are neccessary.

Add a new dataset class.
Create a config file accordingly.
Perform training and evaluation.

Add a new dataset

Datasets in MMSegmentation require image and semantic segmentation maps to be placed in folders with the same perfix. To support a new dataset, we may need to modify the original file structure.

In this tutorial, we give an example of converting the dataset. You may refer to docs for details about dataset reorganization.

We use Standord Background Dataset as an example. The dataset contains 715 images chosen from existing public datasets LabelMe, MSRC, PASCAL VOC and Geometric Context. Images from these datasets are mainly outdoor scenes, each containing approximately 320-by-240 pixels. In this tutorial, we use the region annotations as labels. There are 8 classes in total, i.e. sky, tree, road, grass, water, building, mountain, and foreground object.

# download and unzip
# !wget http://dags.stanford.edu/data/iccv09Data.tar.gz -O standford_background.tar.gz
# !tar xf standford_background.tar.gz

explore the Potsdam dataset

overview

# Let's take a look at the dataset
import mmcv
import matplotlib.pyplot as plt
from fastcore.basics import *
from fastai.vision.all import *
from fastai.torch_basics import *
import warnings
warnings.filterwarnings("ignore")
import kornia
from kornia.constants import Resample
from kornia.color import *
from kornia import augmentation as K
import kornia.augmentation as F
import kornia.augmentation.random_generator as rg
from torchvision.transforms import functional as tvF
from torchvision.transforms import transforms
from torchvision.transforms import PILToTensor

import matplotlib.pyplot as plt
import numpy as np

set_seed(105)
train_a_path = Path("/home/ubuntu/sharedData/swp/dlLab/fastaiRepository/fastai/data/rsData/kaggleOriginal/Potsdam/2_Ortho_RGB/")
label_a_path = Path("/home/ubuntu/sharedData/swp/dlLab/fastaiRepository/fastai/data/rsData/kaggleOriginal/Potsdam/5_labels_for_participants/")
dsm_path = Path("/home/ubuntu/sharedData/swp/dlLab/fastaiRepository/fastai/data/rsData/kaggleOriginal/Potsdam/1_dsm/1_DSM/")
ndsm_path = Path("/home/ubuntu/sharedData/swp/dlLab/fastaiRepository/fastai/data/rsData/kaggleOriginal/Potsdam/1_dsm_normalisation/1_DSM_normalisation/")
imgNames = get_image_files(train_a_path)
lblNames = get_image_files(label_a_path)
dsmNames = get_image_files(dsm_path)
# data
imgNames[0]= Path('/home/ubuntu/sharedData/swp/dlLab/fastaiRepository/fastai/data/rsData/kaggleOriginal/Potsdam/2_Ortho_RGB/top_potsdam_7_7_RGB.tif')
lblNames[0]= Path('/home/ubuntu/sharedData/swp/dlLab/fastaiRepository/fastai/data/rsData/kaggleOriginal/Potsdam/5_labels_for_participants/top_potsdam_7_7_label.tif')
dsmNames[0]=Path('/home/ubuntu/sharedData/swp/dlLab/fastaiRepository/fastai/data/rsData/kaggleOriginal/Potsdam/1_dsm/1_DSM/dsm_potsdam_02_11.tif')

img = mmcv.imread(imgNames[0],channel_order='rgb')
plt.figure(figsize=(8, 8))
plt.imshow(img)
plt.axis('off')
plt.show()

<Figure size 576x576 with 0 Axes>

<matplotlib.image.AxesImage at 0x7fc2cbee9730>

(-0.5, 5999.5, 5999.5, -0.5)

torch.cuda.empty_cache()
!nvidia-smi

Thu Nov 25 07:20:06 2021       
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 430.26       Driver Version: 430.26       CUDA Version: 10.2     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  TITAN Xp            Off  | 00000000:05:00.0 Off |                  N/A |
| 23%   38C    P8    18W / 250W |     10MiB / 12194MiB |      0%      Default |
+-------------------------------+----------------------+----------------------+
|   1  TITAN Xp            Off  | 00000000:09:00.0 Off |                  N/A |
| 23%   33C    P8     9W / 250W |     10MiB / 12196MiB |      0%      Default |
+-------------------------------+----------------------+----------------------+
                                                                               
+-----------------------------------------------------------------------------+
| Processes:                                                       GPU Memory |
|  GPU       PID   Type   Process name                             Usage      |
|=============================================================================|
|  No running processes found                                                 |
+-----------------------------------------------------------------------------+

look at the annotations

transform between different types

to_tensor = transforms.ToTensor()
to_pil = transforms.ToPILImage()
rgbImage = Image.open(imgNames[0])
lblImage = Image.open(lblNames[0])
dsmImage = Image.open(dsmNames[0])
rgbTensor = image2tensor(rgbImage)
lblTensor = image2tensor(lblImage)
dsmTensor = image2tensor(dsmImage)

type(lblTensor)
rgbTensor.shape
lblTensor.shape
dsmTensor.shape
torch.unique(lblTensor)
lblTensor.shape

torch.Tensor

torch.Size([3, 6000, 6000])

torch.Size([1, 6000, 6000])

torch.Size([1, 6000, 6000])

tensor([0, 1, 2, 3, 4, 5], dtype=torch.uint8)

torch.Size([1, 6000, 6000])

# pay attention to the dimension, different software package will always leading to different dimensions of the image:
# PIL:(C,H,W)
# SKImage: (H,W,C)
rgbArray = to_np(rgbTensor).transpose(1,2,0)
lblArray = to_np(lblTensor).transpose(1,2,0)
dsmArray = to_np(dsmTensor).transpose(1,2,0)
np.unique(lblArray)

array([0, 1, 2, 3, 4, 5], dtype=uint8)

original image is composed of 0 and 255, we need to have a change, turn to the grad scale image with constant values

rgbArray.shape
type(rgbArray)

(6000, 6000, 3)

numpy.ndarray

grayscale images

palette = {0 : (255, 255, 255), # Impervious surfaces (white)
           1 : (0, 0, 255),     # Buildings (blue)
           2 : (0, 255, 255),   # Low vegetation (cyan)
           3 : (0, 255, 0),     # Trees (green)
           4 : (255, 255, 0),   # Cars (yellow)
           5 : (255, 0, 0),     # Clutter (red)
           6 : (0, 0, 0)}       # Undefined (black)
invert_palette = {v: k for k, v in palette.items()}
paletteValue = list(palette.values())
paletteValue

[(255, 255, 255),
 (0, 0, 255),
 (0, 255, 255),
 (0, 255, 0),
 (255, 255, 0),
 (255, 0, 0),
 (0, 0, 0)]

def convert_to_color(arr_2d, palette=palette):
    """ Numeric labels to RGB-color encoding """
    arr_3d = np.zeros((arr_2d.shape[0], arr_2d.shape[1], 3), dtype=np.uint8)

    for c, i in palette.items():
        m = arr_2d == c
        arr_3d[m] = i

    return arr_3d

# original label is RGB, we need to have a grayscale label
def convert_from_color(arr_3d, palette=invert_palette):
    """ RGB-color encoding to grayscale labels """
    arr_2d = np.zeros((arr_3d.shape[0], arr_3d.shape[1]), dtype=np.uint8)

    for c, i in palette.items():
        m = np.all(arr_3d == np.array(c).reshape(1, 1, 3), axis=2)
        arr_2d[m] = i

    return arr_2d

# np.unique(convert_from_color(lblArray))

transformedArray  = convert_from_color(lblArray)
show_image(lblImage)
show_image(transformedArray,cmap='gray')

<AxesSubplot:>

<AxesSubplot:>

type(transformedArray)

numpy.ndarray

turn to the array to grayscale image, type is "P"

temp = Image.fromarray(transformedArray).convert('P')
temp.putpalette(np.array(paletteValue, dtype=np.uint8))
# same as the array has shown!
temp
type(temp)
# np.unique(temp)

PIL.Image.Image

transform the whole dataset

lblNames[0].parent

Path('/home/ubuntu/sharedData/swp/dlLab/fastaiRepository/fastai/data/rsData/kaggleOriginal/Potsdam/5_labels_for_participants')

print(f'label shape using PIL to read is {lblImage.shape}')

label shape using PIL to read is (6000, 6000)

shapes are different, so this will decide how we will convert the RGB label to the grayscale label

lblNames[0]

Path('/home/ubuntu/sharedData/swp/dlLab/fastaiRepository/fastai/data/rsData/kaggleOriginal/Potsdam/5_labels_for_participants/top_potsdam_7_7_label.tif')

# turn the images in the annotations to grayscale
classes = ['Impervious surface','Buildings','Low vegetation','Trees','Cars','Clutter','Background']
def turnDataset2Gray():
    for index in range(len(lblNames)):
        temp = np.asarray(convert_from_color(io.imread(lblNames[index])),dtype='uint8')
        io.imsave(lblNames[index].parent/f'{lblNames[index].stem}.tif',temp)
        print(f'{lblNames[index].stem} saved')
#     lblImage = Image.open(lblNames[index])
#     lblTensor= image2tensor(lblImage)
#     lblArray = to_np(lblTensor).transpose(1,2,0)
#     transformedArray  = convert_from_color(lblArray)
#     temp = Image.fromarray(transformedArray).convert('P')
#     temp.putpalette(np.array(paletteValue, dtype=np.uint8))
#     temp.save(lblNames[index].parent/f'{lblNames[index].stem}.tif')
# turnDataset2Gray()

import numpy as np
from PIL import Image
# convert dataset annotation to semantic segmentation map
data_root = '/home/ubuntu/sharedData/swp/dlLab/fastaiRepository/fastai/data/rsData/kaggleOriginal/Potsdam/'
img_dir = '/home/ubuntu/sharedData/swp/dlLab/fastaiRepository/fastai/data/rsData/kaggleOriginal/Potsdam/2_Ortho_RGB/'
ann_dir = '/home/ubuntu/sharedData/swp/dlLab/fastaiRepository/fastai/data/rsData/kaggleOriginal/Potsdam/5_labels_for_participants/'
split_dir = '/home/ubuntu/sharedData/swp/dlLab/fastaiRepository/fastai/data/rsData/kaggleOriginal/Potsdam/splits/'

osp.join(data_root,ann_dir)

'/home/ubuntu/sharedData/swp/dlLab/fastaiRepository/fastai/data/rsData/kaggleOriginal/Potsdam/5_labels_for_participants/'

classes

['Impervious surface',
 'Buildings',
 'Low vegetation',
 'Trees',
 'Cars',
 'Clutter',
 'Background']

# Let's take a look at the segmentation map we got
import matplotlib.patches as mpatches
img = Image.open(lblNames[0])
img.shape
print(f'label image has {np.unique(np.array(img))} unique values')
print(f'label image converted to RGB has {np.unique(convert_to_color(np.array(img)))} unique values')
test = convert_to_color(np.array(img))
test.shape
plt.figure(figsize=(8, 6))
im = plt.imshow(convert_to_color(np.array(img)))
# create a patch (proxy artist) for every color 
patches = [mpatches.Patch(color=np.array(paletteValue[i])/255., 
                          label=classes[i]) for i in range(7)]
# put those patched as legend-handles into the legend
plt.legend(handles=patches, bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0., 
           fontsize='large')
plt.axis('off')
plt.show()

(6000, 6000)

label image has [0 1 2 3 4 5] unique values
label image converted to RGB has [  0 255] unique values

(6000, 6000, 3)

<Figure size 576x432 with 0 Axes>

<matplotlib.legend.Legend at 0x7fc2d0363520>

(-0.5, 5999.5, 5999.5, -0.5)

split the dataset

len(lblNames)

296

palette

{0: (255, 255, 255),
 1: (0, 0, 255),
 2: (0, 255, 255),
 3: (0, 255, 0),
 4: (255, 255, 0),
 5: (255, 0, 0),
 6: (0, 0, 0)}

paletteValue

[(255, 255, 255),
 (0, 0, 255),
 (0, 255, 255),
 (0, 255, 0),
 (255, 255, 0),
 (255, 0, 0),
 (0, 0, 0)]

classes

['Impervious surface',
 'Buildings',
 'Low vegetation',
 'Trees',
 'Cars',
 'Clutter',
 'Background']

from mmseg.datasets.builder import DATASETS
from mmseg.datasets.custom import CustomDataset

@DATASETS.register_module()
class IsprsDataset(CustomDataset):
  CLASSES = classes
  PALETTE = palette
  def __init__(self, **kwargs):
    super().__init__(img_suffix='RGB.tif', seg_map_suffix='label.tif', 
                      **kwargs)
    self.split = 'splits'
    assert osp.exists(self.img_dir) and self.split is not None

Create a config file

In the next step, we need to modify the config for the training. To accelerate the process, we finetune the model from trained weights.

from mmcv import Config
cfg = Config.fromfile('/home/ubuntu/sharedData/swp/dlLabSwp/favourite/swpFastTest/mmsegmentation/configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py')

cfg

Config (path: /home/ubuntu/sharedData/swp/dlLabSwp/favourite/swpFastTest/mmsegmentation/configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py): {'norm_cfg': {'type': 'SyncBN', 'requires_grad': True}, 'model': {'type': 'EncoderDecoder', 'pretrained': 'open-mmlab://resnet50_v1c', 'backbone': {'type': 'ResNetV1c', 'depth': 50, 'num_stages': 4, 'out_indices': (0, 1, 2, 3), 'dilations': (1, 1, 2, 4), 'strides': (1, 2, 1, 1), 'norm_cfg': {'type': 'SyncBN', 'requires_grad': True}, 'norm_eval': False, 'style': 'pytorch', 'contract_dilation': True}, 'decode_head': {'type': 'PSPHead', 'in_channels': 2048, 'in_index': 3, 'channels': 512, 'pool_scales': (1, 2, 3, 6), 'dropout_ratio': 0.1, 'num_classes': 19, 'norm_cfg': {'type': 'SyncBN', 'requires_grad': True}, 'align_corners': False, 'loss_decode': {'type': 'CrossEntropyLoss', 'use_sigmoid': False, 'loss_weight': 1.0}}, 'auxiliary_head': {'type': 'FCNHead', 'in_channels': 1024, 'in_index': 2, 'channels': 256, 'num_convs': 1, 'concat_input': False, 'dropout_ratio': 0.1, 'num_classes': 19, 'norm_cfg': {'type': 'SyncBN', 'requires_grad': True}, 'align_corners': False, 'loss_decode': {'type': 'CrossEntropyLoss', 'use_sigmoid': False, 'loss_weight': 0.4}}, 'train_cfg': {}, 'test_cfg': {'mode': 'whole'}}, 'dataset_type': 'CityscapesDataset', 'data_root': 'data/cityscapes/', 'img_norm_cfg': {'mean': [123.675, 116.28, 103.53], 'std': [58.395, 57.12, 57.375], 'to_rgb': True}, 'crop_size': (512, 1024), 'train_pipeline': [{'type': 'LoadImageFromFile'}, {'type': 'LoadAnnotations'}, {'type': 'Resize', 'img_scale': (2048, 1024), 'ratio_range': (0.5, 2.0)}, {'type': 'RandomCrop', 'crop_size': (512, 1024), 'cat_max_ratio': 0.75}, {'type': 'RandomFlip', 'prob': 0.5}, {'type': 'PhotoMetricDistortion'}, {'type': 'Normalize', 'mean': [123.675, 116.28, 103.53], 'std': [58.395, 57.12, 57.375], 'to_rgb': True}, {'type': 'Pad', 'size': (512, 1024), 'pad_val': 0, 'seg_pad_val': 255}, {'type': 'DefaultFormatBundle'}, {'type': 'Collect', 'keys': ['img', 'gt_semantic_seg']}], 'test_pipeline': [{'type': 'LoadImageFromFile'}, {'type': 'MultiScaleFlipAug', 'img_scale': (2048, 1024), 'flip': False, 'transforms': [{'type': 'Resize', 'keep_ratio': True}, {'type': 'RandomFlip'}, {'type': 'Normalize', 'mean': [123.675, 116.28, 103.53], 'std': [58.395, 57.12, 57.375], 'to_rgb': True}, {'type': 'ImageToTensor', 'keys': ['img']}, {'type': 'Collect', 'keys': ['img']}]}], 'data': {'samples_per_gpu': 2, 'workers_per_gpu': 2, 'train': {'type': 'CityscapesDataset', 'data_root': 'data/cityscapes/', 'img_dir': 'leftImg8bit/train', 'ann_dir': 'gtFine/train', 'pipeline': [{'type': 'LoadImageFromFile'}, {'type': 'LoadAnnotations'}, {'type': 'Resize', 'img_scale': (2048, 1024), 'ratio_range': (0.5, 2.0)}, {'type': 'RandomCrop', 'crop_size': (512, 1024), 'cat_max_ratio': 0.75}, {'type': 'RandomFlip', 'prob': 0.5}, {'type': 'PhotoMetricDistortion'}, {'type': 'Normalize', 'mean': [123.675, 116.28, 103.53], 'std': [58.395, 57.12, 57.375], 'to_rgb': True}, {'type': 'Pad', 'size': (512, 1024), 'pad_val': 0, 'seg_pad_val': 255}, {'type': 'DefaultFormatBundle'}, {'type': 'Collect', 'keys': ['img', 'gt_semantic_seg']}]}, 'val': {'type': 'CityscapesDataset', 'data_root': 'data/cityscapes/', 'img_dir': 'leftImg8bit/val', 'ann_dir': 'gtFine/val', 'pipeline': [{'type': 'LoadImageFromFile'}, {'type': 'MultiScaleFlipAug', 'img_scale': (2048, 1024), 'flip': False, 'transforms': [{'type': 'Resize', 'keep_ratio': True}, {'type': 'RandomFlip'}, {'type': 'Normalize', 'mean': [123.675, 116.28, 103.53], 'std': [58.395, 57.12, 57.375], 'to_rgb': True}, {'type': 'ImageToTensor', 'keys': ['img']}, {'type': 'Collect', 'keys': ['img']}]}]}, 'test': {'type': 'CityscapesDataset', 'data_root': 'data/cityscapes/', 'img_dir': 'leftImg8bit/val', 'ann_dir': 'gtFine/val', 'pipeline': [{'type': 'LoadImageFromFile'}, {'type': 'MultiScaleFlipAug', 'img_scale': (2048, 1024), 'flip': False, 'transforms': [{'type': 'Resize', 'keep_ratio': True}, {'type': 'RandomFlip'}, {'type': 'Normalize', 'mean': [123.675, 116.28, 103.53], 'std': [58.395, 57.12, 57.375], 'to_rgb': True}, {'type': 'ImageToTensor', 'keys': ['img']}, {'type': 'Collect', 'keys': ['img']}]}]}}, 'log_config': {'interval': 50, 'hooks': [{'type': 'TextLoggerHook', 'by_epoch': False}]}, 'dist_params': {'backend': 'nccl'}, 'log_level': 'INFO', 'load_from': None, 'resume_from': None, 'workflow': [('train', 1)], 'cudnn_benchmark': True, 'optimizer': {'type': 'SGD', 'lr': 0.01, 'momentum': 0.9, 'weight_decay': 0.0005}, 'optimizer_config': {}, 'lr_config': {'policy': 'poly', 'power': 0.9, 'min_lr': 0.0001, 'by_epoch': False}, 'runner': {'type': 'IterBasedRunner', 'max_iters': 40000}, 'checkpoint_config': {'by_epoch': False, 'interval': 4000}, 'evaluation': {'interval': 4000, 'metric': 'mIoU', 'pre_eval': True}}

Since the given config is used to train PSPNet on cityscapes dataset, we need to modify it accordingly for our new dataset.

data_root

'/home/ubuntu/sharedData/swp/dlLab/fastaiRepository/fastai/data/rsData/kaggleOriginal/Potsdam/'

from mmseg.apis import set_random_seed

# Since we use ony one GPU, BN is used instead of SyncBN
cfg.norm_cfg = dict(type='BN', requires_grad=True)
cfg.model.backbone.norm_cfg = cfg.norm_cfg
cfg.model.decode_head.norm_cfg = cfg.norm_cfg
cfg.model.auxiliary_head.norm_cfg = cfg.norm_cfg
# modify num classes of the model in decode/auxiliary head
cfg.model.decode_head.num_classes = 7
cfg.model.auxiliary_head.num_classes = 7

# Modify dataset type and path
cfg.dataset_type = 'IsprsDataset'
cfg.data_root = data_root

cfg.img_norm_cfg = dict(
    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
cfg.crop_size = (512, 512)
cfg.train_pipeline = [
    dict(type='LoadImageFromFile'),
    dict(type='LoadAnnotations'),
#     dict(type='Resize', img_scale=(6000, 6000), ratio_range=(0.5, 2.0)),
    dict(type='RandomCrop', crop_size=cfg.crop_size, cat_max_ratio=0.45),

    dict(type='RandomFlip', flip_ratio=0.5),
    dict(type='PhotoMetricDistortion'),
    dict(type='Normalize', **cfg.img_norm_cfg),
    dict(type='Pad', size=cfg.crop_size, pad_val=0, seg_pad_val=255),
    dict(type='DefaultFormatBundle'),
    dict(type='Collect', keys=['img', 'gt_semantic_seg']),
]
cfg.test_pipeline = [
    dict(type='LoadImageFromFile'),
#     dict(type='RandomCrop', crop_size=cfg.crop_size, cat_max_ratio=0.45),
    dict(
        type='MultiScaleFlipAug',
        img_scale=(512, 512),
        img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
        flip=False,
        transforms=[
#             dict(type='RandomCrop', crop_size=cfg.crop_size, cat_max_ratio=0.45),
            dict(type='Resize', keep_ratio=True),
            dict(type='RandomFlip'),
            dict(type='Normalize', **cfg.img_norm_cfg),
            dict(type='ImageToTensor', keys=['img']),
            dict(type='Collect', keys=['img']),
        ])
]

# change the data to repeatDataset
cfg.data = dict(
    samples_per_gpu=4,
    workers_per_gpu=4,
    train=dict(
        type='RepeatDataset',
        times=100,
        dataset=dict(
            type=cfg.dataset_type,
            data_root=cfg.data_root,
            img_dir='2_Ortho_RGB/training',
            ann_dir='5_labels_for_participants/training',
            pipeline=cfg.train_pipeline
            )),
     val=dict(
            type=cfg.dataset_type,
            data_root=cfg.data_root,
            img_dir='2_Ortho_RGB/validation',
            ann_dir='5_labels_for_participants/validation',
            pipeline=cfg.test_pipeline
            ),           
     test=dict(
            type=cfg.dataset_type,
            data_root=cfg.data_root,
            img_dir='2_Ortho_RGB/validation',
            ann_dir='5_labels_for_participants/validation',
            pipeline=cfg.test_pipeline
            )
)

# We can still use the pre-trained Mask RCNN model though we do not need to

# use the mask branch
cfg.load_from = './checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'

# Set up working dir to save files and logs.
cfg.work_dir = './work_dirs/tutorial'

cfg.runner = dict(type='EpochBasedRunner', max_epochs=200)
# cfg.runner.max_iters = 200
# cfg.log_config.interval = 10
# cfg.evaluation.interval = 200
# cfg.checkpoint_config.interval = 200
cfg.evaluation.interval = 1
cfg.checkpoint_config.interval = 800
cfg.log_config = dict(
    interval=90, hooks=[dict(type='TextLoggerHook', by_epoch=True)])


# Set seed to facitate reproducing the result
cfg.seed = 0
set_random_seed(0, deterministic=False)
cfg.gpu_ids = range(1)

# Let's have a look at the final config used for training
print(f'Config:\n{cfg.pretty_text}')

Config:
norm_cfg = dict(type='BN', requires_grad=True)
model = dict(
    type='EncoderDecoder',
    pretrained='open-mmlab://resnet50_v1c',
    backbone=dict(
        type='ResNetV1c',
        depth=50,
        num_stages=4,
        out_indices=(0, 1, 2, 3),
        dilations=(1, 1, 2, 4),
        strides=(1, 2, 1, 1),
        norm_cfg=dict(type='BN', requires_grad=True),
        norm_eval=False,
        style='pytorch',
        contract_dilation=True),
    decode_head=dict(
        type='PSPHead',
        in_channels=2048,
        in_index=3,
        channels=512,
        pool_scales=(1, 2, 3, 6),
        dropout_ratio=0.1,
        num_classes=7,
        norm_cfg=dict(type='BN', requires_grad=True),
        align_corners=False,
        loss_decode=dict(
            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
    auxiliary_head=dict(
        type='FCNHead',
        in_channels=1024,
        in_index=2,
        channels=256,
        num_convs=1,
        concat_input=False,
        dropout_ratio=0.1,
        num_classes=7,
        norm_cfg=dict(type='BN', requires_grad=True),
        align_corners=False,
        loss_decode=dict(
            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
    train_cfg=dict(),
    test_cfg=dict(mode='whole'))
dataset_type = 'IsprsDataset'
data_root = '/home/ubuntu/sharedData/swp/dlLab/fastaiRepository/fastai/data/rsData/kaggleOriginal/Potsdam/'
img_norm_cfg = dict(
    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
crop_size = (512, 512)
train_pipeline = [
    dict(type='LoadImageFromFile'),
    dict(type='LoadAnnotations'),
    dict(type='RandomCrop', crop_size=(512, 512), cat_max_ratio=0.45),
    dict(type='RandomFlip', flip_ratio=0.5),
    dict(type='PhotoMetricDistortion'),
    dict(
        type='Normalize',
        mean=[123.675, 116.28, 103.53],
        std=[58.395, 57.12, 57.375],
        to_rgb=True),
    dict(type='Pad', size=(512, 512), pad_val=0, seg_pad_val=255),
    dict(type='DefaultFormatBundle'),
    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
]
test_pipeline = [
    dict(type='LoadImageFromFile'),
    dict(
        type='MultiScaleFlipAug',
        img_scale=(512, 512),
        img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
        flip=False,
        transforms=[
            dict(type='Resize', keep_ratio=True),
            dict(type='RandomFlip'),
            dict(
                type='Normalize',
                mean=[123.675, 116.28, 103.53],
                std=[58.395, 57.12, 57.375],
                to_rgb=True),
            dict(type='ImageToTensor', keys=['img']),
            dict(type='Collect', keys=['img'])
        ])
]
data = dict(
    samples_per_gpu=4,
    workers_per_gpu=4,
    train=dict(
        type='RepeatDataset',
        times=100,
        dataset=dict(
            type='IsprsDataset',
            data_root=
            '/home/ubuntu/sharedData/swp/dlLab/fastaiRepository/fastai/data/rsData/kaggleOriginal/Potsdam/',
            img_dir='2_Ortho_RGB/training',
            ann_dir='5_labels_for_participants/training',
            pipeline=[
                dict(type='LoadImageFromFile'),
                dict(type='LoadAnnotations'),
                dict(
                    type='RandomCrop',
                    crop_size=(512, 512),
                    cat_max_ratio=0.45),
                dict(type='RandomFlip', flip_ratio=0.5),
                dict(type='PhotoMetricDistortion'),
                dict(
                    type='Normalize',
                    mean=[123.675, 116.28, 103.53],
                    std=[58.395, 57.12, 57.375],
                    to_rgb=True),
                dict(type='Pad', size=(512, 512), pad_val=0, seg_pad_val=255),
                dict(type='DefaultFormatBundle'),
                dict(type='Collect', keys=['img', 'gt_semantic_seg'])
            ])),
    val=dict(
        type='IsprsDataset',
        data_root=
        '/home/ubuntu/sharedData/swp/dlLab/fastaiRepository/fastai/data/rsData/kaggleOriginal/Potsdam/',
        img_dir='2_Ortho_RGB/validation',
        ann_dir='5_labels_for_participants/validation',
        pipeline=[
            dict(type='LoadImageFromFile'),
            dict(
                type='MultiScaleFlipAug',
                img_scale=(512, 512),
                img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
                flip=False,
                transforms=[
                    dict(type='Resize', keep_ratio=True),
                    dict(type='RandomFlip'),
                    dict(
                        type='Normalize',
                        mean=[123.675, 116.28, 103.53],
                        std=[58.395, 57.12, 57.375],
                        to_rgb=True),
                    dict(type='ImageToTensor', keys=['img']),
                    dict(type='Collect', keys=['img'])
                ])
        ]),
    test=dict(
        type='IsprsDataset',
        data_root=
        '/home/ubuntu/sharedData/swp/dlLab/fastaiRepository/fastai/data/rsData/kaggleOriginal/Potsdam/',
        img_dir='2_Ortho_RGB/validation',
        ann_dir='5_labels_for_participants/validation',
        pipeline=[
            dict(type='LoadImageFromFile'),
            dict(
                type='MultiScaleFlipAug',
                img_scale=(512, 512),
                img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
                flip=False,
                transforms=[
                    dict(type='Resize', keep_ratio=True),
                    dict(type='RandomFlip'),
                    dict(
                        type='Normalize',
                        mean=[123.675, 116.28, 103.53],
                        std=[58.395, 57.12, 57.375],
                        to_rgb=True),
                    dict(type='ImageToTensor', keys=['img']),
                    dict(type='Collect', keys=['img'])
                ])
        ]))
log_config = dict(
    interval=90, hooks=[dict(type='TextLoggerHook', by_epoch=True)])
dist_params = dict(backend='nccl')
log_level = 'INFO'
load_from = './checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth'
resume_from = None
workflow = [('train', 1)]
cudnn_benchmark = True
optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
optimizer_config = dict()
lr_config = dict(policy='poly', power=0.9, min_lr=0.0001, by_epoch=False)
runner = dict(type='EpochBasedRunner', max_epochs=200)
checkpoint_config = dict(by_epoch=False, interval=800)
evaluation = dict(interval=1, metric='mIoU', pre_eval=True)
work_dir = './work_dirs/tutorial'
seed = 0
gpu_ids = range(0, 1)

Train and Evaluation

cfg.data.train

{'type': 'RepeatDataset',
 'times': 100,
 'dataset': {'type': 'IsprsDataset',
  'data_root': '/home/ubuntu/sharedData/swp/dlLab/fastaiRepository/fastai/data/rsData/kaggleOriginal/Potsdam/',
  'img_dir': '2_Ortho_RGB/training',
  'ann_dir': '5_labels_for_participants/training',
  'pipeline': [{'type': 'LoadImageFromFile'},
   {'type': 'LoadAnnotations'},
   {'type': 'RandomCrop', 'crop_size': (512, 512), 'cat_max_ratio': 0.45},
   {'type': 'RandomFlip', 'flip_ratio': 0.5},
   {'type': 'PhotoMetricDistortion'},
   {'type': 'Normalize',
    'mean': [123.675, 116.28, 103.53],
    'std': [58.395, 57.12, 57.375],
    'to_rgb': True},
   {'type': 'Pad', 'size': (512, 512), 'pad_val': 0, 'seg_pad_val': 255},
   {'type': 'DefaultFormatBundle'},
   {'type': 'Collect', 'keys': ['img', 'gt_semantic_seg']}]}}

cfg

Config (path: /home/ubuntu/sharedData/swp/dlLabSwp/favourite/swpFastTest/mmsegmentation/configs/pspnet/pspnet_r50-d8_512x1024_40k_cityscapes.py): {'norm_cfg': {'type': 'BN', 'requires_grad': True}, 'model': {'type': 'EncoderDecoder', 'pretrained': 'open-mmlab://resnet50_v1c', 'backbone': {'type': 'ResNetV1c', 'depth': 50, 'num_stages': 4, 'out_indices': (0, 1, 2, 3), 'dilations': (1, 1, 2, 4), 'strides': (1, 2, 1, 1), 'norm_cfg': {'type': 'BN', 'requires_grad': True}, 'norm_eval': False, 'style': 'pytorch', 'contract_dilation': True}, 'decode_head': {'type': 'PSPHead', 'in_channels': 2048, 'in_index': 3, 'channels': 512, 'pool_scales': (1, 2, 3, 6), 'dropout_ratio': 0.1, 'num_classes': 7, 'norm_cfg': {'type': 'BN', 'requires_grad': True}, 'align_corners': False, 'loss_decode': {'type': 'CrossEntropyLoss', 'use_sigmoid': False, 'loss_weight': 1.0}}, 'auxiliary_head': {'type': 'FCNHead', 'in_channels': 1024, 'in_index': 2, 'channels': 256, 'num_convs': 1, 'concat_input': False, 'dropout_ratio': 0.1, 'num_classes': 7, 'norm_cfg': {'type': 'BN', 'requires_grad': True}, 'align_corners': False, 'loss_decode': {'type': 'CrossEntropyLoss', 'use_sigmoid': False, 'loss_weight': 0.4}}, 'train_cfg': {}, 'test_cfg': {'mode': 'whole'}}, 'dataset_type': 'IsprsDataset', 'data_root': '/home/ubuntu/sharedData/swp/dlLab/fastaiRepository/fastai/data/rsData/kaggleOriginal/Potsdam/', 'img_norm_cfg': {'mean': [123.675, 116.28, 103.53], 'std': [58.395, 57.12, 57.375], 'to_rgb': True}, 'crop_size': (512, 512), 'train_pipeline': [{'type': 'LoadImageFromFile'}, {'type': 'LoadAnnotations'}, {'type': 'RandomCrop', 'crop_size': (512, 512), 'cat_max_ratio': 0.45}, {'type': 'RandomFlip', 'flip_ratio': 0.5}, {'type': 'PhotoMetricDistortion'}, {'type': 'Normalize', 'mean': [123.675, 116.28, 103.53], 'std': [58.395, 57.12, 57.375], 'to_rgb': True}, {'type': 'Pad', 'size': (512, 512), 'pad_val': 0, 'seg_pad_val': 255}, {'type': 'DefaultFormatBundle'}, {'type': 'Collect', 'keys': ['img', 'gt_semantic_seg']}], 'test_pipeline': [{'type': 'LoadImageFromFile'}, {'type': 'MultiScaleFlipAug', 'img_scale': (512, 512), 'img_ratios': [0.5, 0.75, 1.0, 1.25, 1.5, 1.75], 'flip': False, 'transforms': [{'type': 'Resize', 'keep_ratio': True}, {'type': 'RandomFlip'}, {'type': 'Normalize', 'mean': [123.675, 116.28, 103.53], 'std': [58.395, 57.12, 57.375], 'to_rgb': True}, {'type': 'ImageToTensor', 'keys': ['img']}, {'type': 'Collect', 'keys': ['img']}]}], 'data': {'samples_per_gpu': 4, 'workers_per_gpu': 4, 'train': {'type': 'RepeatDataset', 'times': 100, 'dataset': {'type': 'IsprsDataset', 'data_root': '/home/ubuntu/sharedData/swp/dlLab/fastaiRepository/fastai/data/rsData/kaggleOriginal/Potsdam/', 'img_dir': '2_Ortho_RGB/training', 'ann_dir': '5_labels_for_participants/training', 'pipeline': [{'type': 'LoadImageFromFile'}, {'type': 'LoadAnnotations'}, {'type': 'RandomCrop', 'crop_size': (512, 512), 'cat_max_ratio': 0.45}, {'type': 'RandomFlip', 'flip_ratio': 0.5}, {'type': 'PhotoMetricDistortion'}, {'type': 'Normalize', 'mean': [123.675, 116.28, 103.53], 'std': [58.395, 57.12, 57.375], 'to_rgb': True}, {'type': 'Pad', 'size': (512, 512), 'pad_val': 0, 'seg_pad_val': 255}, {'type': 'DefaultFormatBundle'}, {'type': 'Collect', 'keys': ['img', 'gt_semantic_seg']}]}}, 'val': {'type': 'IsprsDataset', 'data_root': '/home/ubuntu/sharedData/swp/dlLab/fastaiRepository/fastai/data/rsData/kaggleOriginal/Potsdam/', 'img_dir': '2_Ortho_RGB/validation', 'ann_dir': '5_labels_for_participants/validation', 'pipeline': [{'type': 'LoadImageFromFile'}, {'type': 'MultiScaleFlipAug', 'img_scale': (512, 512), 'img_ratios': [0.5, 0.75, 1.0, 1.25, 1.5, 1.75], 'flip': False, 'transforms': [{'type': 'Resize', 'keep_ratio': True}, {'type': 'RandomFlip'}, {'type': 'Normalize', 'mean': [123.675, 116.28, 103.53], 'std': [58.395, 57.12, 57.375], 'to_rgb': True}, {'type': 'ImageToTensor', 'keys': ['img']}, {'type': 'Collect', 'keys': ['img']}]}]}, 'test': {'type': 'IsprsDataset', 'data_root': '/home/ubuntu/sharedData/swp/dlLab/fastaiRepository/fastai/data/rsData/kaggleOriginal/Potsdam/', 'img_dir': '2_Ortho_RGB/validation', 'ann_dir': '5_labels_for_participants/validation', 'pipeline': [{'type': 'LoadImageFromFile'}, {'type': 'MultiScaleFlipAug', 'img_scale': (512, 512), 'img_ratios': [0.5, 0.75, 1.0, 1.25, 1.5, 1.75], 'flip': False, 'transforms': [{'type': 'Resize', 'keep_ratio': True}, {'type': 'RandomFlip'}, {'type': 'Normalize', 'mean': [123.675, 116.28, 103.53], 'std': [58.395, 57.12, 57.375], 'to_rgb': True}, {'type': 'ImageToTensor', 'keys': ['img']}, {'type': 'Collect', 'keys': ['img']}]}]}}, 'log_config': {'interval': 90, 'hooks': [{'type': 'TextLoggerHook', 'by_epoch': True}]}, 'dist_params': {'backend': 'nccl'}, 'log_level': 'INFO', 'load_from': './checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth', 'resume_from': None, 'workflow': [('train', 1)], 'cudnn_benchmark': True, 'optimizer': {'type': 'SGD', 'lr': 0.01, 'momentum': 0.9, 'weight_decay': 0.0005}, 'optimizer_config': {}, 'lr_config': {'policy': 'poly', 'power': 0.9, 'min_lr': 0.0001, 'by_epoch': False}, 'runner': {'type': 'EpochBasedRunner', 'max_epochs': 200}, 'checkpoint_config': {'by_epoch': False, 'interval': 800}, 'evaluation': {'interval': 1, 'metric': 'mIoU', 'pre_eval': True}, 'work_dir': './work_dirs/tutorial', 'seed': 0, 'gpu_ids': range(0, 1)}

from mmseg.datasets import build_dataset
from mmseg.models import build_segmentor
from mmseg.apis import train_segmentor


# Build the dataset
datasets = [build_dataset(cfg.data.train)]

# Build the detector
model = build_segmentor(
    cfg.model, train_cfg=cfg.get('train_cfg'), test_cfg=cfg.get('test_cfg'))
# Add an attribute for visualization convenience
model.CLASSES = datasets[0].CLASSES

2021-11-25 07:20:27,123 - mmseg - INFO - Loaded 18 images

type(model)

mmseg.models.segmentors.encoder_decoder.EncoderDecoder

# Create work_dir
mmcv.mkdir_or_exist(osp.abspath(cfg.work_dir))
train_segmentor(model, datasets, cfg, distributed=False, validate=True, 
                meta=dict())

2021-11-25 07:20:29,987 - mmseg - INFO - Loaded 255 images
2021-11-25 07:20:29,988 - mmseg - INFO - load checkpoint from ./checkpoints/pspnet_r50-d8_512x1024_40k_cityscapes_20200605_003338-2966598c.pth
2021-11-25 07:20:29,989 - mmseg - INFO - Use load_from_local loader
2021-11-25 07:20:30,110 - mmseg - WARNING - The model and loaded state dict do not match exactly

size mismatch for decode_head.conv_seg.weight: copying a param with shape torch.Size([19, 512, 1, 1]) from checkpoint, the shape in current model is torch.Size([7, 512, 1, 1]).
size mismatch for decode_head.conv_seg.bias: copying a param with shape torch.Size([19]) from checkpoint, the shape in current model is torch.Size([7]).
size mismatch for auxiliary_head.conv_seg.weight: copying a param with shape torch.Size([19, 256, 1, 1]) from checkpoint, the shape in current model is torch.Size([7, 256, 1, 1]).
size mismatch for auxiliary_head.conv_seg.bias: copying a param with shape torch.Size([19]) from checkpoint, the shape in current model is torch.Size([7]).
2021-11-25 07:20:30,115 - mmseg - INFO - Start running, host: ubuntu@3a26d25f88f6, work_dir: /home/ubuntu/sharedData/swp/dlLabSwp/blog/myBlog/_notebooks/work_dirs/tutorial
2021-11-25 07:20:30,116 - mmseg - INFO - Hooks will be executed in the following order:
before_run:
(VERY_HIGH   ) PolyLrUpdaterHook                  
(NORMAL      ) CheckpointHook                     
(LOW         ) EvalHook                           
(VERY_LOW    ) TextLoggerHook                     
 -------------------- 
before_train_epoch:
(VERY_HIGH   ) PolyLrUpdaterHook                  
(LOW         ) IterTimerHook                      
(LOW         ) EvalHook                           
(VERY_LOW    ) TextLoggerHook                     
 -------------------- 
before_train_iter:
(VERY_HIGH   ) PolyLrUpdaterHook                  
(LOW         ) IterTimerHook                      
(LOW         ) EvalHook                           
 -------------------- 
after_train_iter:
(ABOVE_NORMAL) OptimizerHook                      
(NORMAL      ) CheckpointHook                     
(LOW         ) IterTimerHook                      
(LOW         ) EvalHook                           
(VERY_LOW    ) TextLoggerHook                     
 -------------------- 
after_train_epoch:
(NORMAL      ) CheckpointHook                     
(LOW         ) EvalHook                           
(VERY_LOW    ) TextLoggerHook                     
 -------------------- 
before_val_epoch:
(LOW         ) IterTimerHook                      
(VERY_LOW    ) TextLoggerHook                     
 -------------------- 
before_val_iter:
(LOW         ) IterTimerHook                      
 -------------------- 
after_val_iter:
(LOW         ) IterTimerHook                      
 -------------------- 
after_val_epoch:
(VERY_LOW    ) TextLoggerHook                     
 -------------------- 
2021-11-25 07:20:30,125 - mmseg - INFO - workflow: [('train', 1)], max: 200 epochs
/home/ubuntu/miniconda3/envs/new/lib/python3.8/site-packages/mmcv/runner/hooks/logger/text.py:55: DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
  mem_mb = torch.tensor([mem / (1024 * 1024)],
2021-11-25 07:21:35,180 - mmseg - INFO - Epoch [1][90/450]	lr: 9.991e-03, eta: 18:02:16, time: 0.722, data_time: 0.042, memory: 7603, decode.loss_ce: 1.0712, decode.acc_seg: 62.1146, aux.loss_ce: 0.4673, aux.acc_seg: 58.9148, loss: 1.5385
/home/ubuntu/miniconda3/envs/new/lib/python3.8/site-packages/mmcv/runner/hooks/logger/text.py:55: DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
  mem_mb = torch.tensor([mem / (1024 * 1024)],
2021-11-25 07:22:33,307 - mmseg - INFO - Epoch [1][180/450]	lr: 9.982e-03, eta: 17:04:00, time: 0.646, data_time: 0.003, memory: 7603, decode.loss_ce: 0.8170, decode.acc_seg: 70.6126, aux.loss_ce: 0.3496, aux.acc_seg: 69.3008, loss: 1.1665
/home/ubuntu/miniconda3/envs/new/lib/python3.8/site-packages/mmcv/runner/hooks/logger/text.py:55: DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
  mem_mb = torch.tensor([mem / (1024 * 1024)],
2021-11-25 07:23:31,663 - mmseg - INFO - Epoch [1][270/450]	lr: 9.973e-03, eta: 16:45:12, time: 0.648, data_time: 0.003, memory: 7603, decode.loss_ce: 0.6983, decode.acc_seg: 75.0388, aux.loss_ce: 0.3033, aux.acc_seg: 73.2817, loss: 1.0015
/home/ubuntu/miniconda3/envs/new/lib/python3.8/site-packages/mmcv/runner/hooks/logger/text.py:55: DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
  mem_mb = torch.tensor([mem / (1024 * 1024)],
2021-11-25 07:24:30,649 - mmseg - INFO - Epoch [1][360/450]	lr: 9.964e-03, eta: 16:37:56, time: 0.655, data_time: 0.003, memory: 7603, decode.loss_ce: 0.6592, decode.acc_seg: 76.3344, aux.loss_ce: 0.2868, aux.acc_seg: 74.6073, loss: 0.9460
/home/ubuntu/miniconda3/envs/new/lib/python3.8/site-packages/mmcv/runner/hooks/logger/text.py:55: DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
  mem_mb = torch.tensor([mem / (1024 * 1024)],
2021-11-25 07:25:29,737 - mmseg - INFO - Epoch [1][450/450]	lr: 9.956e-03, eta: 16:33:31, time: 0.656, data_time: 0.003, memory: 7603, decode.loss_ce: 0.6370, decode.acc_seg: 77.5461, aux.loss_ce: 0.2789, aux.acc_seg: 75.6568, loss: 0.9160

[>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 255/255, 0.3 task/s, elapsed: 1008s, ETA:     0s

2021-11-25 07:42:17,893 - mmseg - INFO - per class results:
2021-11-25 07:42:17,894 - mmseg - INFO - 
+--------------------+-------+-------+
|       Class        |  IoU  |  Acc  |
+--------------------+-------+-------+
| Impervious surface |  4.56 |  4.6  |
|     Buildings      |  6.19 |  7.12 |
|   Low vegetation   | 48.38 | 55.43 |
|       Trees        |  0.0  |  0.0  |
|        Cars        |  0.0  |  0.0  |
|      Clutter       |  3.49 | 87.37 |
|     Background     |  nan  |  nan  |
+--------------------+-------+-------+
2021-11-25 07:42:17,895 - mmseg - INFO - Summary:
2021-11-25 07:42:17,895 - mmseg - INFO - 
+-------+-------+-------+
|  aAcc |  mIoU |  mAcc |
+-------+-------+-------+
| 16.21 | 10.44 | 25.75 |
+-------+-------+-------+
2021-11-25 07:42:17,896 - mmseg - INFO - Epoch(val) [1][255]	aAcc: 0.1621, mIoU: 0.1044, mAcc: 0.2575, IoU.Impervious surface: 0.0456, IoU.Buildings: 0.0619, IoU.Low vegetation: 0.4838, IoU.Trees: 0.0000, IoU.Cars: 0.0000, IoU.Clutter: 0.0349, IoU.Background: nan, Acc.Impervious surface: 0.0460, Acc.Buildings: 0.0712, Acc.Low vegetation: 0.5543, Acc.Trees: 0.0000, Acc.Cars: 0.0000, Acc.Clutter: 0.8737, Acc.Background: nan
/home/ubuntu/miniconda3/envs/new/lib/python3.8/site-packages/mmcv/runner/hooks/logger/text.py:55: DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
  mem_mb = torch.tensor([mem / (1024 * 1024)],
2021-11-25 07:43:19,536 - mmseg - INFO - Epoch [2][90/450]	lr: 9.947e-03, eta: 16:37:08, time: 0.684, data_time: 0.042, memory: 7603, decode.loss_ce: 0.5669, decode.acc_seg: 79.6583, aux.loss_ce: 0.2528, aux.acc_seg: 77.7080, loss: 0.8198
/home/ubuntu/miniconda3/envs/new/lib/python3.8/site-packages/mmcv/runner/hooks/logger/text.py:55: DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
  mem_mb = torch.tensor([mem / (1024 * 1024)],
2021-11-25 07:44:18,423 - mmseg - INFO - Epoch [2][180/450]	lr: 9.938e-03, eta: 16:33:02, time: 0.654, data_time: 0.003, memory: 7603, decode.loss_ce: 0.5781, decode.acc_seg: 79.1762, aux.loss_ce: 0.2569, aux.acc_seg: 77.1837, loss: 0.8349
/home/ubuntu/miniconda3/envs/new/lib/python3.8/site-packages/mmcv/runner/hooks/logger/text.py:55: DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
  mem_mb = torch.tensor([mem / (1024 * 1024)],
2021-11-25 07:45:17,557 - mmseg - INFO - Epoch [2][270/450]	lr: 9.929e-03, eta: 16:30:15, time: 0.657, data_time: 0.003, memory: 7603, decode.loss_ce: 0.5597, decode.acc_seg: 79.5922, aux.loss_ce: 0.2497, aux.acc_seg: 77.6859, loss: 0.8094
2021-11-25 07:46:10,288 - mmseg - INFO - Saving checkpoint at 800 iterations
/home/ubuntu/miniconda3/envs/new/lib/python3.8/site-packages/mmcv/runner/hooks/logger/text.py:55: DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
  mem_mb = torch.tensor([mem / (1024 * 1024)],
2021-11-25 07:46:20,230 - mmseg - INFO - Epoch [2][360/450]	lr: 9.920e-03, eta: 16:34:21, time: 0.696, data_time: 0.003, memory: 7603, decode.loss_ce: 0.5047, decode.acc_seg: 81.7269, aux.loss_ce: 0.2278, aux.acc_seg: 79.5494, loss: 0.7325
/home/ubuntu/miniconda3/envs/new/lib/python3.8/site-packages/mmcv/runner/hooks/logger/text.py:55: DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
  mem_mb = torch.tensor([mem / (1024 * 1024)],
2021-11-25 07:47:19,526 - mmseg - INFO - Epoch [2][450/450]	lr: 9.911e-03, eta: 16:31:51, time: 0.659, data_time: 0.003, memory: 7603, decode.loss_ce: 0.4897, decode.acc_seg: 82.0476, aux.loss_ce: 0.2205, aux.acc_seg: 80.0745, loss: 0.7101

[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 255/255, 0.3 task/s, elapsed: 871s, ETA:     0s

2021-11-25 08:01:51,099 - mmseg - INFO - per class results:
2021-11-25 08:01:51,100 - mmseg - INFO - 
+--------------------+-------+-------+
|       Class        |  IoU  |  Acc  |
+--------------------+-------+-------+
| Impervious surface | 10.97 | 11.28 |
|     Buildings      | 36.27 | 55.12 |
|   Low vegetation   | 32.39 | 37.55 |
|       Trees        |  0.0  |  0.0  |
|        Cars        |  0.0  |  0.0  |
|      Clutter       |  3.07 | 69.82 |
|     Background     |  nan  |  nan  |
+--------------------+-------+-------+
2021-11-25 08:01:51,101 - mmseg - INFO - Summary:
2021-11-25 08:01:51,101 - mmseg - INFO - 
+------+-------+-------+
| aAcc |  mIoU |  mAcc |
+------+-------+-------+
| 29.9 | 13.78 | 28.96 |
+------+-------+-------+
2021-11-25 08:01:51,103 - mmseg - INFO - Epoch(val) [2][255]	aAcc: 0.2990, mIoU: 0.1378, mAcc: 0.2896, IoU.Impervious surface: 0.1097, IoU.Buildings: 0.3627, IoU.Low vegetation: 0.3239, IoU.Trees: 0.0000, IoU.Cars: 0.0000, IoU.Clutter: 0.0307, IoU.Background: nan, Acc.Impervious surface: 0.1128, Acc.Buildings: 0.5512, Acc.Low vegetation: 0.3755, Acc.Trees: 0.0000, Acc.Cars: 0.0000, Acc.Clutter: 0.6982, Acc.Background: nan
/home/ubuntu/miniconda3/envs/new/lib/python3.8/site-packages/mmcv/runner/hooks/logger/text.py:55: DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
  mem_mb = torch.tensor([mem / (1024 * 1024)],
2021-11-25 08:02:52,903 - mmseg - INFO - Epoch [3][90/450]	lr: 9.902e-03, eta: 16:33:17, time: 0.686, data_time: 0.042, memory: 7603, decode.loss_ce: 0.5552, decode.acc_seg: 79.9243, aux.loss_ce: 0.2500, aux.acc_seg: 78.0673, loss: 0.8053
/home/ubuntu/miniconda3/envs/new/lib/python3.8/site-packages/mmcv/runner/hooks/logger/text.py:55: DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
  mem_mb = torch.tensor([mem / (1024 * 1024)],
2021-11-25 08:03:51,842 - mmseg - INFO - Epoch [3][180/450]	lr: 9.893e-03, eta: 16:30:28, time: 0.655, data_time: 0.003, memory: 7603, decode.loss_ce: 0.5174, decode.acc_seg: 81.1654, aux.loss_ce: 0.2307, aux.acc_seg: 79.3683, loss: 0.7481
/home/ubuntu/miniconda3/envs/new/lib/python3.8/site-packages/mmcv/runner/hooks/logger/text.py:55: DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
  mem_mb = torch.tensor([mem / (1024 * 1024)],
2021-11-25 08:04:51,265 - mmseg - INFO - Epoch [3][270/450]	lr: 9.884e-03, eta: 16:28:32, time: 0.660, data_time: 0.003, memory: 7603, decode.loss_ce: 0.4541, decode.acc_seg: 83.4478, aux.loss_ce: 0.2066, aux.acc_seg: 81.5367, loss: 0.6607
/home/ubuntu/miniconda3/envs/new/lib/python3.8/site-packages/mmcv/runner/hooks/logger/text.py:55: DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
  mem_mb = torch.tensor([mem / (1024 * 1024)],
2021-11-25 08:05:50,692 - mmseg - INFO - Epoch [3][360/450]	lr: 9.875e-03, eta: 16:26:45, time: 0.660, data_time: 0.003, memory: 7603, decode.loss_ce: 0.4549, decode.acc_seg: 83.6564, aux.loss_ce: 0.2031, aux.acc_seg: 81.9106, loss: 0.6580
/home/ubuntu/miniconda3/envs/new/lib/python3.8/site-packages/mmcv/runner/hooks/logger/text.py:55: DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
  mem_mb = torch.tensor([mem / (1024 * 1024)],
2021-11-25 08:06:50,311 - mmseg - INFO - Epoch [3][450/450]	lr: 9.866e-03, eta: 16:25:17, time: 0.662, data_time: 0.003, memory: 7603, decode.loss_ce: 0.4616, decode.acc_seg: 83.3123, aux.loss_ce: 0.2084, aux.acc_seg: 81.4651, loss: 0.6701

[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 255/255, 0.3 task/s, elapsed: 828s, ETA:     0s

2021-11-25 08:20:38,571 - mmseg - INFO - per class results:
2021-11-25 08:20:38,572 - mmseg - INFO - 
+--------------------+-------+-------+
|       Class        |  IoU  |  Acc  |
+--------------------+-------+-------+
| Impervious surface |  8.7  | 11.05 |
|     Buildings      | 13.95 | 18.84 |
|   Low vegetation   |  3.78 |  3.93 |
|       Trees        |  0.0  |  0.0  |
|        Cars        |  0.0  |  0.0  |
|      Clutter       |  3.53 | 89.79 |
|     Background     |  nan  |  nan  |
+--------------------+-------+-------+
2021-11-25 08:20:38,573 - mmseg - INFO - Summary:
2021-11-25 08:20:38,574 - mmseg - INFO - 
+-------+------+------+
|  aAcc | mIoU | mAcc |
+-------+------+------+
| 11.92 | 4.99 | 20.6 |
+-------+------+------+
2021-11-25 08:20:38,575 - mmseg - INFO - Epoch(val) [3][255]	aAcc: 0.1192, mIoU: 0.0499, mAcc: 0.2060, IoU.Impervious surface: 0.0870, IoU.Buildings: 0.1395, IoU.Low vegetation: 0.0378, IoU.Trees: 0.0000, IoU.Cars: 0.0000, IoU.Clutter: 0.0353, IoU.Background: nan, Acc.Impervious surface: 0.1105, Acc.Buildings: 0.1884, Acc.Low vegetation: 0.0393, Acc.Trees: 0.0000, Acc.Cars: 0.0000, Acc.Clutter: 0.8979, Acc.Background: nan
/home/ubuntu/miniconda3/envs/new/lib/python3.8/site-packages/mmcv/runner/hooks/logger/text.py:55: DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
  mem_mb = torch.tensor([mem / (1024 * 1024)],
2021-11-25 08:21:40,397 - mmseg - INFO - Epoch [4][90/450]	lr: 9.857e-03, eta: 16:26:04, time: 0.686, data_time: 0.043, memory: 7603, decode.loss_ce: 0.4568, decode.acc_seg: 83.5926, aux.loss_ce: 0.2049, aux.acc_seg: 81.8774, loss: 0.6617
/home/ubuntu/miniconda3/envs/new/lib/python3.8/site-packages/mmcv/runner/hooks/logger/text.py:55: DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
  mem_mb = torch.tensor([mem / (1024 * 1024)],
2021-11-25 08:22:39,394 - mmseg - INFO - Epoch [4][180/450]	lr: 9.848e-03, eta: 16:23:59, time: 0.656, data_time: 0.003, memory: 7603, decode.loss_ce: 0.4156, decode.acc_seg: 84.9214, aux.loss_ce: 0.1904, aux.acc_seg: 82.9777, loss: 0.6060
2021-11-25 08:23:25,414 - mmseg - INFO - Saving checkpoint at 1600 iterations
/home/ubuntu/miniconda3/envs/new/lib/python3.8/site-packages/mmcv/runner/hooks/logger/text.py:55: DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
  mem_mb = torch.tensor([mem / (1024 * 1024)],
2021-11-25 08:23:41,218 - mmseg - INFO - Epoch [4][270/450]	lr: 9.840e-03, eta: 16:24:35, time: 0.687, data_time: 0.003, memory: 7603, decode.loss_ce: 0.4378, decode.acc_seg: 84.0178, aux.loss_ce: 0.2046, aux.acc_seg: 81.5142, loss: 0.6424
/home/ubuntu/miniconda3/envs/new/lib/python3.8/site-packages/mmcv/runner/hooks/logger/text.py:55: DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
  mem_mb = torch.tensor([mem / (1024 * 1024)],
2021-11-25 08:24:40,672 - mmseg - INFO - Epoch [4][360/450]	lr: 9.831e-03, eta: 16:22:58, time: 0.661, data_time: 0.003, memory: 7603, decode.loss_ce: 0.4556, decode.acc_seg: 83.6867, aux.loss_ce: 0.2063, aux.acc_seg: 81.7279, loss: 0.6619
/home/ubuntu/miniconda3/envs/new/lib/python3.8/site-packages/mmcv/runner/hooks/logger/text.py:55: DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
  mem_mb = torch.tensor([mem / (1024 * 1024)],
2021-11-25 08:25:40,232 - mmseg - INFO - Epoch [4][450/450]	lr: 9.822e-03, eta: 16:21:30, time: 0.662, data_time: 0.003, memory: 7603, decode.loss_ce: 0.4505, decode.acc_seg: 83.5123, aux.loss_ce: 0.2042, aux.acc_seg: 81.4684, loss: 0.6547

[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 255/255, 0.3 task/s, elapsed: 903s, ETA:     0s

2021-11-25 08:40:43,501 - mmseg - INFO - per class results:
2021-11-25 08:40:43,502 - mmseg - INFO - 
+--------------------+-------+-------+
|       Class        |  IoU  |  Acc  |
+--------------------+-------+-------+
| Impervious surface | 28.19 | 43.28 |
|     Buildings      | 60.57 | 92.73 |
|   Low vegetation   |  1.3  |  1.32 |
|       Trees        |  0.0  |  0.0  |
|        Cars        |  0.0  |  0.0  |
|      Clutter       |  1.87 |  4.43 |
|     Background     |  nan  |  nan  |
+--------------------+-------+-------+
2021-11-25 08:40:43,503 - mmseg - INFO - Summary:
2021-11-25 08:40:43,503 - mmseg - INFO - 
+-------+-------+-------+
|  aAcc |  mIoU |  mAcc |
+-------+-------+-------+
| 44.13 | 15.32 | 23.63 |
+-------+-------+-------+
2021-11-25 08:40:43,505 - mmseg - INFO - Epoch(val) [4][255]	aAcc: 0.4413, mIoU: 0.1532, mAcc: 0.2363, IoU.Impervious surface: 0.2819, IoU.Buildings: 0.6057, IoU.Low vegetation: 0.0130, IoU.Trees: 0.0000, IoU.Cars: 0.0000, IoU.Clutter: 0.0187, IoU.Background: nan, Acc.Impervious surface: 0.4328, Acc.Buildings: 0.9273, Acc.Low vegetation: 0.0132, Acc.Trees: 0.0000, Acc.Cars: 0.0000, Acc.Clutter: 0.0443, Acc.Background: nan
/home/ubuntu/miniconda3/envs/new/lib/python3.8/site-packages/mmcv/runner/hooks/logger/text.py:55: DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
  mem_mb = torch.tensor([mem / (1024 * 1024)],
2021-11-25 08:41:45,326 - mmseg - INFO - Epoch [5][90/450]	lr: 9.813e-03, eta: 16:21:48, time: 0.686, data_time: 0.043, memory: 7603, decode.loss_ce: 0.4300, decode.acc_seg: 84.4160, aux.loss_ce: 0.1969, aux.acc_seg: 82.6397, loss: 0.6270
/home/ubuntu/miniconda3/envs/new/lib/python3.8/site-packages/mmcv/runner/hooks/logger/text.py:55: DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
  mem_mb = torch.tensor([mem / (1024 * 1024)],
2021-11-25 08:42:44,258 - mmseg - INFO - Epoch [5][180/450]	lr: 9.804e-03, eta: 16:19:53, time: 0.655, data_time: 0.003, memory: 7603, decode.loss_ce: 0.4371, decode.acc_seg: 84.0168, aux.loss_ce: 0.2003, aux.acc_seg: 82.1757, loss: 0.6374
/home/ubuntu/miniconda3/envs/new/lib/python3.8/site-packages/mmcv/runner/hooks/logger/text.py:55: DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
  mem_mb = torch.tensor([mem / (1024 * 1024)],
2021-11-25 08:43:43,591 - mmseg - INFO - Epoch [5][270/450]	lr: 9.795e-03, eta: 16:18:19, time: 0.659, data_time: 0.003, memory: 7603, decode.loss_ce: 0.4491, decode.acc_seg: 83.6826, aux.loss_ce: 0.2066, aux.acc_seg: 81.3558, loss: 0.6556
/home/ubuntu/miniconda3/envs/new/lib/python3.8/site-packages/mmcv/runner/hooks/logger/text.py:55: DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
  mem_mb = torch.tensor([mem / (1024 * 1024)],
2021-11-25 08:44:43,053 - mmseg - INFO - Epoch [5][360/450]	lr: 9.786e-03, eta: 16:16:54, time: 0.661, data_time: 0.003, memory: 7603, decode.loss_ce: 0.4246, decode.acc_seg: 84.8247, aux.loss_ce: 0.1925, aux.acc_seg: 83.1097, loss: 0.6171
/home/ubuntu/miniconda3/envs/new/lib/python3.8/site-packages/mmcv/runner/hooks/logger/text.py:55: DeprecationWarning: an integer is required (got type float).  Implicit conversion to integers using __int__ is deprecated, and may be removed in a future version of Python.
  mem_mb = torch.tensor([mem / (1024 * 1024)],
2021-11-25 08:45:42,537 - mmseg - INFO - Epoch [5][450/450]	lr: 9.777e-03, eta: 16:15:32, time: 0.661, data_time: 0.003, memory: 7603, decode.loss_ce: 0.3962, decode.acc_seg: 85.3740, aux.loss_ce: 0.1813, aux.acc_seg: 83.5963, loss: 0.5774

[>>>>>>>>>>>>>>>>>>>>>>>>>>>>>] 255/255, 0.3 task/s, elapsed: 883s, ETA:     0s

Inference with trained model

# img = mmcv.imread('iccv09Data/images/6000124.jpg')

# model.cfg = cfg
# result = inference_segmentor(model, img)
# plt.figure(figsize=(8, 6))
# show_result_pyplot(model, img, result, palette)