Upload 8 files

model/RTFNet.py

@@ -0,0 +1,272 @@
+# coding:utf-8
+# By Yuxiang Sun, Aug. 2, 2019
+# Email: sun.yuxiang@outlook.com
+
+import torch
+import torch.nn as nn 
+import torchvision.models as models
+import cv2
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy.ndimage import gaussian_filter
+class RTFNet(nn.Module):
+
+    def __init__(self, n_class):
+        super(RTFNet, self).__init__()
+
+        self.num_resnet_layers = 152
+
+        if self.num_resnet_layers == 18:
+            resnet_raw_model1 = models.resnet18(pretrained=True)
+            resnet_raw_model2 = models.resnet18(pretrained=True)
+            self.inplanes = 512
+        elif self.num_resnet_layers == 34:
+            resnet_raw_model1 = models.resnet34(pretrained=True)
+            resnet_raw_model2 = models.resnet34(pretrained=True)
+            self.inplanes = 512
+        elif self.num_resnet_layers == 50:
+            resnet_raw_model1 = models.resnet50(pretrained=True)
+            resnet_raw_model2 = models.resnet50(pretrained=True)
+            self.inplanes = 2048
+        elif self.num_resnet_layers == 101:
+            resnet_raw_model1 = models.resnet101(pretrained=True)
+            resnet_raw_model2 = models.resnet101(pretrained=True)
+            self.inplanes = 2048
+        elif self.num_resnet_layers == 152:
+            resnet_raw_model1 = models.resnet152(pretrained=True)
+            resnet_raw_model2 = models.resnet152(pretrained=True)
+            self.inplanes = 2048
+
+        ########  Thermal ENCODER  ########
+ 
+        self.encoder_thermal_conv1 = nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False) 
+        self.encoder_thermal_conv1.weight.data = torch.unsqueeze(torch.mean(resnet_raw_model1.conv1.weight.data, dim=1), dim=1)
+        self.encoder_thermal_bn1 = resnet_raw_model1.bn1
+        self.encoder_thermal_relu = resnet_raw_model1.relu
+        self.encoder_thermal_maxpool = resnet_raw_model1.maxpool
+        self.encoder_thermal_layer1 = resnet_raw_model1.layer1
+        self.encoder_thermal_layer2 = resnet_raw_model1.layer2
+        self.encoder_thermal_layer3 = resnet_raw_model1.layer3
+        self.encoder_thermal_layer4 = resnet_raw_model1.layer4
+
+        ########  RGB ENCODER  ########
+ 
+        self.encoder_rgb_conv1 = resnet_raw_model2.conv1
+        self.encoder_rgb_bn1 = resnet_raw_model2.bn1
+        self.encoder_rgb_relu = resnet_raw_model2.relu
+        self.encoder_rgb_maxpool = resnet_raw_model2.maxpool
+        self.encoder_rgb_layer1 = resnet_raw_model2.layer1
+        self.encoder_rgb_layer2 = resnet_raw_model2.layer2
+        self.encoder_rgb_layer3 = resnet_raw_model2.layer3
+        self.encoder_rgb_layer4 = resnet_raw_model2.layer4
+
+
+
+        ########  DECODER  ########
+
+        self.deconv1 = self._make_transpose_layer(TransBottleneck, self.inplanes//2, 2, stride=2) # using // for python 3.6
+        self.deconv2 = self._make_transpose_layer(TransBottleneck, self.inplanes//2, 2, stride=2) # using // for python 3.6
+        self.deconv3 = self._make_transpose_layer(TransBottleneck, self.inplanes//2, 2, stride=2) # using // for python 3.6
+        self.deconv4 = self._make_transpose_layer(TransBottleneck, self.inplanes//2, 2, stride=2) # using // for python 3.6
+        self.deconv5 = self._make_transpose_layer(TransBottleneck, n_class, 2, stride=2)
+ 
+    def _make_transpose_layer(self, block, planes, blocks, stride=1):
+
+        upsample = None
+        if stride != 1:
+            upsample = nn.Sequential(
+                nn.ConvTranspose2d(self.inplanes, planes, kernel_size=2, stride=stride, padding=0, bias=False),
+                nn.BatchNorm2d(planes),
+            ) 
+        elif self.inplanes != planes:
+            upsample = nn.Sequential(
+                nn.Conv2d(self.inplanes, planes, kernel_size=1, stride=stride, padding=0, bias=False),
+                nn.BatchNorm2d(planes),
+            ) 
+ 
+        for m in upsample.modules():
+            if isinstance(m, nn.ConvTranspose2d):
+                nn.init.xavier_uniform_(m.weight.data)
+            elif isinstance(m, nn.BatchNorm2d):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
+
+        layers = []
+
+        for i in range(1, blocks):
+            layers.append(block(self.inplanes, self.inplanes))
+
+        layers.append(block(self.inplanes, planes, stride, upsample))
+        self.inplanes = planes
+
+        return nn.Sequential(*layers)
+ 
+    def forward(self, input):
+
+        rgb = input[:,:3]
+        thermal = input[:,3:]
+
+        verbose = False
+
+        # encoder
+
+        ######################################################################
+
+        if verbose: print("rgb.size() original: ", rgb.size())  # (480, 640)
+        if verbose: print("thermal.size() original: ", thermal.size()) # (480, 640)
+
+        ######################################################################
+
+        rgb = self.encoder_rgb_conv1(rgb)
+        if verbose: print("rgb.size() after conv1: ", rgb.size()) # (240, 320)
+        rgb = self.encoder_rgb_bn1(rgb)
+        if verbose: print("rgb.size() after bn1: ", rgb.size())  # (240, 320)
+        rgb = self.encoder_rgb_relu(rgb)
+        if verbose: print("rgb.size() after relu: ", rgb.size())  # (240, 320)
+
+        thermal = self.encoder_thermal_conv1(thermal)
+        if verbose: print("thermal.size() after conv1: ", thermal.size()) # (240, 320)
+        thermal = self.encoder_thermal_bn1(thermal)
+        if verbose: print("thermal.size() after bn1: ", thermal.size()) # (240, 320)
+        thermal = self.encoder_thermal_relu(thermal)
+        if verbose: print("thermal.size() after relu: ", thermal.size())  # (240, 320)
+
+        rgb = rgb + thermal
+
+        rgb = self.encoder_rgb_maxpool(rgb)
+        if verbose: print("rgb.size() after maxpool: ", rgb.size()) # (120, 160)
+
+        thermal = self.encoder_thermal_maxpool(thermal)
+        if verbose: print("thermal.size() after maxpool: ", thermal.size()) # (120, 160)
+
+        ######################################################################
+
+        rgb = self.encoder_rgb_layer1(rgb)
+        if verbose: print("rgb.size() after layer1: ", rgb.size()) # (120, 160)
+        thermal = self.encoder_thermal_layer1(thermal)
+        if verbose: print("thermal.size() after layer1: ", thermal.size()) # (120, 160)
+
+        rgb = rgb + thermal
+
+        ######################################################################
+ 
+        rgb = self.encoder_rgb_layer2(rgb)
+        if verbose: print("rgb.size() after layer2: ", rgb.size()) # (60, 80)
+        thermal = self.encoder_thermal_layer2(thermal)
+        if verbose: print("thermal.size() after layer2: ", thermal.size()) # (60, 80)
+
+        rgb = rgb + thermal
+
+        ######################################################################
+
+        rgb = self.encoder_rgb_layer3(rgb)
+        if verbose: print("rgb.size() after layer3: ", rgb.size()) # (30, 40)
+        thermal = self.encoder_thermal_layer3(thermal)
+        if verbose: print("thermal.size() after layer3: ", thermal.size()) # (30, 40)
+
+        rgb = rgb + thermal
+
+        ######################################################################
+
+        rgb = self.encoder_rgb_layer4(rgb)
+        if verbose: print("rgb.size() after layer4: ", rgb.size()) # (15, 20)
+        thermal = self.encoder_thermal_layer4(thermal)
+        if verbose: print("thermal.size() after layer4: ", thermal.size()) # (15, 20)
+
+        chenzeyang = thermal[0]
+        chenzeyang = torch.squeeze(chenzeyang)
+        att = chenzeyang.sum(axis=0).detach().cpu().numpy()
+        att = gaussian_filter(att, sigma=2)
+        att -= att.min()
+        att /= att.max()
+        # att1 = att.detach().cpu().numpy()
+        attmap = cv2.resize(att, (640, 480), interpolation=cv2.INTER_CUBIC)
+        attmap_uint8 = np.uint8(255 * attmap)
+        heatmap = cv2.applyColorMap(attmap_uint8, cv2.COLORMAP_JET)
+        plt.imshow(cv2.cvtColor(heatmap, cv2.COLOR_BGR2RGB))
+        # attmap = 255 - attmap.astype("uint8")
+        # plt.imshow(attmap)
+        plt.savefig("/opt/data/private/RTFNet/RTF_heatrgb_039.png")
+        plt.show()
+        #cv2.imwrite("/opt/data/private/czy/heatmap_00001D.png", heatmap)
+        chenbo = 1
+        fuse = rgb + thermal
+
+        ######################################################################
+
+        # decoder
+
+        fuse = self.deconv1(fuse)
+        if verbose: print("fuse after deconv1: ", fuse.size()) # (30, 40)
+        fuse = self.deconv2(fuse)
+        if verbose: print("fuse after deconv2: ", fuse.size()) # (60, 80)
+        fuse = self.deconv3(fuse)
+        if verbose: print("fuse after deconv3: ", fuse.size()) # (120, 160)
+        fuse = self.deconv4(fuse)
+        if verbose: print("fuse after deconv4: ", fuse.size()) # (240, 320)
+        fuse = self.deconv5(fuse)
+        if verbose: print("fuse after deconv5: ", fuse.size()) # (480, 640)
+
+        return fuse
+  
+class TransBottleneck(nn.Module):
+
+    def __init__(self, inplanes, planes, stride=1, upsample=None):
+        super(TransBottleneck, self).__init__()
+        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)  
+        self.bn1 = nn.BatchNorm2d(planes)
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False)  
+        self.bn2 = nn.BatchNorm2d(planes)
+
+        if upsample is not None and stride != 1:
+            self.conv3 = nn.ConvTranspose2d(planes, planes, kernel_size=2, stride=stride, padding=0, bias=False)  
+        else:
+            self.conv3 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)  
+
+        self.bn3 = nn.BatchNorm2d(planes)
+        self.relu = nn.ReLU(inplace=True)
+        self.upsample = upsample
+        self.stride = stride
+ 
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.xavier_uniform_(m.weight.data)
+            elif isinstance(m, nn.ConvTranspose2d):
+                nn.init.xavier_uniform_(m.weight.data)
+            elif isinstance(m, nn.BatchNorm2d):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
+
+    def forward(self, x):
+        residual = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        if self.upsample is not None:
+            residual = self.upsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+def unit_test():
+    num_minibatch = 2
+    rgb = torch.randn(num_minibatch, 3, 480, 640).cuda(0)
+    thermal = torch.randn(num_minibatch, 1, 480, 640).cuda(0)
+    rtf_net = RTFNet(20).cuda(0)
+    input = torch.cat((rgb, thermal), dim=1)
+    rtf_net(input)
+    #print('The model: ', rtf_net.modules)
+
+if __name__ == '__main__':
+    unit_test()

model/__init__.py

@@ -0,0 +1 @@
+from .RTFNet import RTFNet

util/KP_dataset.py

@@ -0,0 +1,93 @@
+# Written by Ukcheol Shin, Jan. 24, 2023 using the following two repositories.
+# MS-UDA: https://github.com/yeong5366/MS-UDA
+# Mask2Former: https://github.com/facebookresearch/Mask2Former
+
+import cv2
+import numpy as np
+import os, torch
+# from imageio import imread
+from torch.nn import functional as F
+from torch.utils.data.dataset import Dataset
+import PIL
+
+class KP_dataset(Dataset):
+
+    def __init__(self, data_dir, split):
+        super(KP_dataset, self).__init__()
+
+        assert (split in ['train', 'val', 'test', 'test_day', 'test_night']),\
+         'split must be train | val | test | test_day | test_night |'
+
+        if split == 'train':        
+            with open(os.path.join(data_dir, 'train_day.txt'), 'r') as file:
+                self.data_list = [name.strip() for idx, name in enumerate(file)]
+            with open(os.path.join(data_dir, 'train_night.txt'), 'r') as file:
+                self.data_list += [name.strip()for idx, name in enumerate(file)]
+        elif split == 'val':            
+            with open(os.path.join(data_dir, 'val_day.txt'), 'r') as file:
+                self.data_list = [name.strip() for idx, name in enumerate(file)]
+            with open(os.path.join(data_dir, 'val_night.txt'), 'r') as file:
+                self.data_list += [name.strip()for idx, name in enumerate(file)]
+        elif split == 'test':            
+            with open(os.path.join(data_dir, 'test_day.txt'), 'r') as file:
+                self.data_list = [name.strip() for idx, name in enumerate(file)]
+            with open(os.path.join(data_dir, 'test_night.txt'), 'r') as file:
+                self.data_list += [name.strip()for idx, name in enumerate(file)]
+        self.data_list.sort()
+
+        self.data_dir  = data_dir
+        self.split     = split
+        self.n_data    = len(self.data_list)
+        self.size_divisibility = -1
+        self.ignore_label = 19
+
+    def read_image(self, name, folder):
+        splited_name = name.split('_')
+        file_path = os.path.join(self.data_dir, 'images', splited_name[0], splited_name[1], folder, splited_name[2].replace('png','jpg',1))
+        image = imread(file_path).astype('float32') # HxWxC
+        return image
+
+    def read_label(self, name, folder):
+        file_path = os.path.join(self.data_dir, '%s/%s' % (folder, name))
+        image     = imread(file_path).astype('float32')
+        return image
+
+    def __getitem__(self, index):
+        name  = self.data_list[index]
+        image_rgb = self.read_image(name, 'visible')                        # 通过实验，我发现KP和PST数据集RGB和thr分开的,即RGB是3通道,thr是1通道
+        image_thr = np.expand_dims(self.read_image(name, 'lwir').mean(axis=2), axis=2)
+        image = np.concatenate((image_rgb,image_thr),axis=2)                # 这句话将RGB图和thr图从通道上连接了,难怪通道数是4
+        label = self.read_label(name, 'labels').astype("double")
+
+        # Pad image and segmentation label here!
+        #image      = torch.as_tensor(np.ascontiguousarray(image.transpose(2, 0, 1)))
+        #label = torch.as_tensor(label.astype("long"))
+        #image = np.asarray(PIL.Image.fromarray(image).resize((self.input_w, self.input_h)))
+        #image = image.astype('float32')
+        image = np.transpose(image, (2,0,1))/255.0
+        #label = np.asarray(PIL.Image.fromarray(label).resize((self.input_w, self.input_h), resample=PIL.Image.NEAREST))
+        #label = label.astype('int64')
+
+        if self.size_divisibility > 0:
+            image_size = (image.shape[-2], image.shape[-1])
+            padding_size = [
+                0,
+                self.size_divisibility - image_size[1],
+                0,
+                self.size_divisibility - image_size[0],
+            ]
+            image      = F.pad(image, padding_size, value=128).contiguous()
+            label = F.pad(label, padding_size, value=self.ignore_label).contiguous()
+
+        image_shape = (image.shape[-2], image.shape[-1])  # h, w
+
+        # Packing data
+        result = {}
+        result["name"]  = name
+        result["image"] = image
+        #result["label"] = label.long()
+
+        return torch.tensor(image), torch.tensor(label), name
+
+    def __len__(self):
+        return self.n_data

util/MF_dataset.py

@@ -0,0 +1,48 @@
+# By Yuxiang Sun, Jul. 3, 2021
+# Email: sun.yuxiang@outlook.com
+
+import os, torch
+from torch.utils.data.dataset import Dataset
+import numpy as np
+import PIL
+
+class MF_dataset(Dataset):
+
+    def __init__(self, data_dir, split, input_h=480, input_w=640 ,transform=[]):
+        super(MF_dataset, self).__init__()
+
+        assert split in ['train', 'val', 'test', 'test_day', 'test_night', 'val_test', 'most_wanted'], \
+            'split must be "train"|"val"|"test"|"test_day"|"test_night"|"val_test"|"most_wanted"'  # test_day, test_night
+
+        with open(os.path.join(data_dir, split+'.txt'), 'r') as f:
+            self.names = [name.strip() for name in f.readlines()]
+
+        self.data_dir  = data_dir
+        self.split     = split
+        self.input_h   = input_h
+        self.input_w   = input_w
+        self.transform = transform
+        self.n_data    = len(self.names)
+
+    def read_image(self, name, folder):
+        file_path = os.path.join(self.data_dir, '%s/%s.png' % (folder, name))
+        image     = np.asarray(PIL.Image.open(file_path))
+        return image
+
+    def __getitem__(self, index):
+        name  = self.names[index]
+        image = self.read_image(name, 'images')
+        label = self.read_image(name, 'labels')
+        for func in self.transform:
+            image, label = func(image, label)
+            
+        image = np.asarray(PIL.Image.fromarray(image).resize((self.input_w, self.input_h)))
+        image = image.astype('float32')
+        image = np.transpose(image, (2,0,1))/255.0
+        label = np.asarray(PIL.Image.fromarray(label).resize((self.input_w, self.input_h), resample=PIL.Image.NEAREST))
+        label = label.astype('int64')
+        
+        return torch.tensor(image), torch.tensor(label), name
+
+    def __len__(self):
+        return self.n_data

util/PST_dataset.py

@@ -0,0 +1,73 @@
+# Written by Ukcheol Shin, Jan. 24, 2023 using the following two repositories.
+# PST900: https://github.com/ShreyasSkandanS/pst900_thermal_rgb
+# Mask2Former: https://github.com/facebookresearch/Mask2Former
+
+import cv2
+import numpy as np
+import os, torch
+# from imageio import imread
+from torch.nn import functional as F
+from torch.utils.data.dataset import Dataset
+
+
+class PST_dataset(Dataset):
+
+    def __init__(self, data_dir, split):
+        super(PST_dataset, self).__init__()
+
+        assert split in ['train', 'val', 'test'], \
+            'split must be "train"|"val"|"test"' 
+
+        # read dataset list, all files have the same name across 'rgb', 'label', 'thermal', 'depth' folders
+        self.data_dir = os.path.join(data_dir, split)   # 这行和下一行都是我修改之后,先把未被修改的data_dir与split结合
+        data_dir = data_dir + split                     # 不加这行data_dir为./dataset/PSTdataset/RGB导致找不到文件,加入之后路径变为./dataset/PSTdataset/split/RGB
+        self.data_list = os.listdir(os.path.join(data_dir, 'rgb'))
+        self.data_list.sort()
+
+        # self.data_dir  = os.path.join(data_dir, split)
+        self.split     = split
+        self.n_data    = len(self.data_list)
+        self.size_divisibility = -1
+        self.ignore_label = 19
+        
+    def read_image(self, name, folder):
+        file_path = os.path.join(self.data_dir, '%s/%s' % (folder, name))
+        image     = imread(file_path).astype('float32')
+        return image
+
+    def __getitem__(self, index):
+        name  = self.data_list[index]
+        image_rgb = self.read_image(name, 'rgb')                            # 通过实验，我发现KP和PST数据集RGB和thr分开的,即RGB是3通道,thr是1通道
+        image_thr = np.expand_dims(self.read_image(name, 'thermal'), axis=2)
+        image = np.concatenate((image_rgb,image_thr),axis=2)
+        # depth = self.read_image(name, 'depth')
+
+        label = self.read_image(name, 'labels').astype("double")
+
+        # Pad image and segmentation label here!
+        #image      = torch.as_tensor(np.ascontiguousarray(image.transpose(2, 0, 1)))
+        #label = torch.as_tensor(label.astype("long"))
+        image = np.transpose(image, (2, 0, 1)) / 255.0
+        if self.size_divisibility > 0:
+            image_size = (image.shape[-2], image.shape[-1])
+            padding_size = [
+                0,
+                self.size_divisibility - image_size[1],
+                0,
+                self.size_divisibility - image_size[0],
+            ]
+            image      = F.pad(image, padding_size, value=128).contiguous()
+            label = F.pad(label, padding_size, value=self.ignore_label).contiguous()
+
+        image_shape = (image.shape[-2], image.shape[-1])  # h, w
+
+        # Packing data
+        #result = {}
+        #result["name"]  = name
+        #result["image"] = image
+        #result["sem_seg_gt"] = sem_seg_gt.long()
+
+        return torch.tensor(image), torch.tensor(label), name
+
+    def __len__(self):
+        return self.n_data

util/__init__.py

@@ -0,0 +1 @@
+

util/augmentation.py

@@ -0,0 +1,95 @@
+import numpy as np
+from PIL import Image
+#from ipdb import set_trace as st
+
+
+class RandomFlip():
+    def __init__(self, prob=0.5):
+        #super(RandomFlip, self).__init__()
+        self.prob = prob
+
+    def __call__(self, image, label):
+        if np.random.rand() < self.prob:
+            image = image[:,::-1]
+            label = label[:,::-1]
+        return image, label
+
+
+class RandomCrop():
+    def __init__(self, crop_rate=0.1, prob=1.0):
+        #super(RandomCrop, self).__init__()
+        self.crop_rate = crop_rate
+        self.prob      = prob
+
+    def __call__(self, image, label):
+        if np.random.rand() < self.prob:
+            w, h, c = image.shape
+
+            h1 = np.random.randint(0, h*self.crop_rate)
+            w1 = np.random.randint(0, w*self.crop_rate)
+            h2 = np.random.randint(h-h*self.crop_rate, h+1)
+            w2 = np.random.randint(w-w*self.crop_rate, w+1)
+
+            image = image[w1:w2, h1:h2]
+            label = label[w1:w2, h1:h2]
+
+        return image, label
+
+
+class RandomCropOut():
+    def __init__(self, crop_rate=0.2, prob=1.0):
+        #super(RandomCropOut, self).__init__()
+        self.crop_rate = crop_rate
+        self.prob      = prob
+
+    def __call__(self, image, label):
+        if np.random.rand() < self.prob:
+            w, h, c = image.shape
+
+            h1 = np.random.randint(0, h*self.crop_rate)
+            w1 = np.random.randint(0, w*self.crop_rate)
+            h2 = int(h1 + h*self.crop_rate)
+            w2 = int(w1 + w*self.crop_rate)
+
+            image[w1:w2, h1:h2] = 0
+            label[w1:w2, h1:h2] = 0
+
+        return image, label
+
+
+class RandomBrightness():
+    def __init__(self, bright_range=0.15, prob=0.9):
+        #super(RandomBrightness, self).__init__()
+        self.bright_range = bright_range
+        self.prob = prob
+
+    def __call__(self, image, label):
+        if np.random.rand() < self.prob:
+            bright_factor = np.random.uniform(1-self.bright_range, 1+self.bright_range)
+            image = (image * bright_factor).astype(image.dtype)
+
+        return image, label
+
+
+class RandomNoise():
+    def __init__(self, noise_range=5, prob=0.9):
+        #super(RandomNoise, self).__init__()
+        self.noise_range = noise_range
+        self.prob = prob
+
+    def __call__(self, image, label):
+        if np.random.rand() < self.prob:
+            w, h, c = image.shape
+
+            noise = np.random.randint(
+                -self.noise_range,
+                self.noise_range,
+                (w,h,c)
+            )
+
+            image = (image + noise).clip(0,255).astype(image.dtype)
+
+        return image, label
+        
+
+

util/util.py

@@ -0,0 +1,83 @@
+# By Yuxiang Sun, Dec. 4, 2020
+# Email: sun.yuxiang@outlook.com
+
+import numpy as np 
+from PIL import Image 
+
+# 0:unlabeled, 1:car, 2:person, 3:bike, 4:curve, 5:car_stop, 6:guardrail, 7:color_cone, 8:bump 
+def get_palette():
+    unlabelled = [0,0,0]
+    car        = [64,0,128]
+    person     = [64,64,0]
+    bike       = [0,128,192]
+    curve      = [0,0,192]
+    car_stop   = [128,128,0]
+    guardrail  = [64,64,128]
+    color_cone = [192,128,128]
+    bump       = [192,64,0]
+    palette    = np.array([unlabelled,car, person, bike, curve, car_stop, guardrail, color_cone, bump])
+
+    #road = [128, 64, 128]
+    #sidewalk = [244, 35, 232]
+    #building = [70, 70, 70]
+    #wall = [102, 102, 156]
+    #fence = [190, 153, 153]
+    #pole = [153, 153, 153]
+    #traffic_light = [250, 170, 30]
+    #traffic_sign = [220, 220, 0]
+    #vegetation = [107, 142, 35]
+    #terrain = [152, 251, 152]
+    #sky = [70, 130, 180]
+    #person = [220, 20, 60]
+    #rider = [255, 0, 0]
+    #car = [0, 0, 142]
+    #truck = [0, 0, 70]
+    #bus = [0, 60, 100]
+    #train = [0, 80, 100]
+    #motorcycle = [0, 0, 230]
+    #bicycle = [119, 11, 32]
+
+    #void = [0, 0, 0]
+    # unlabelled = [0, 0, 0]
+    # fire_extinhuisher = [0, 0, 255]
+    # backpack = [0, 255, 0]
+    # hand_drill = [255, 0, 0]
+    # rescue_randy = [255, 255, 255]
+    # palette = np.array([unlabelled, fire_extinhuisher, backpack, hand_drill, rescue_randy]).astype(np.uint8)
+    return palette
+
+def visualize(image_name, predictions, weight_name):
+    palette = get_palette()
+    for (i, pred) in enumerate(predictions):
+        pred = predictions[i].cpu().numpy()
+        img = np.zeros((pred.shape[0], pred.shape[1], 3), dtype=np.uint8)
+        for cid in range(0, len(palette)): # fix the mistake from the MFNet code on Dec.27, 2019
+            img[pred == cid] = palette[cid]
+        img = Image.fromarray(np.uint8(img))
+        img.save('run/Pred_' + weight_name + '_' + image_name[i] + '.png')
+
+def compute_results(conf_total):
+    n_class =  conf_total.shape[0]
+    consider_unlabeled = True  # must consider the unlabeled, please set it to True
+    if consider_unlabeled is True:
+        start_index = 0
+    else:
+        start_index = 1
+    precision_per_class = np.zeros(n_class)
+    recall_per_class = np.zeros(n_class)
+    iou_per_class = np.zeros(n_class)
+    for cid in range(start_index, n_class): # cid: class id
+        if conf_total[start_index:, cid].sum() == 0:
+            precision_per_class[cid] =  np.nan
+        else:
+            precision_per_class[cid] = float(conf_total[cid, cid]) / float(conf_total[start_index:, cid].sum()) # precision = TP/TP+FP
+        if conf_total[cid, start_index:].sum() == 0:
+            recall_per_class[cid] = np.nan
+        else:
+            recall_per_class[cid] = float(conf_total[cid, cid]) / float(conf_total[cid, start_index:].sum()) # recall = TP/TP+FN
+        if (conf_total[cid, start_index:].sum() + conf_total[start_index:, cid].sum() - conf_total[cid, cid]) == 0:
+            iou_per_class[cid] = np.nan
+        else:
+            iou_per_class[cid] = float(conf_total[cid, cid]) / float((conf_total[cid, start_index:].sum() + conf_total[start_index:, cid].sum() - conf_total[cid, cid])) # IoU = TP/TP+FP+FN
+
+    return precision_per_class, recall_per_class, iou_per_class