Add files via upload

add lr_scheduler

Author: junqiangchen

model/__pycache__/__init__.cpython-36.pyc

@@ -3,7 +3,6 @@
 import torch
 from .lovasz import _lovasz_hinge, _lovasz_softmax
 from typing import Optional, Union
-from torch.nn.modules.loss import _Loss
 
 
 # binary loss
@@ -231,6 +230,9 @@ def forward(self, y_pred_logits, y_true):
 
 
 class LovaszLoss(nn.Module):
+    """
+    mutil LovaszLoss
+    """
     def __init__(self, per_image=False, ignore=None):
         super(LovaszLoss, self).__init__()
         self.ignore = ignore

model/__pycache__/dataset.cpython-36.pyc

@@ -1,3 +1,4 @@
+import numpy as np
 from torch import Tensor
 import torch
 import torch.nn.functional as F
@@ -44,6 +45,24 @@ def multiclass_dice_coeff(input: Tensor, target: Tensor):
     return dice / (input.shape[1] - 1)
 
 
+def multiclass_dice_coeffv2(input: Tensor, target: Tensor):
+    Batchsize, Channel = input.shape[0], input.shape[1]
+    y_pred = input.float().contiguous().view(Batchsize, Channel, -1)
+    y_true = target.long().contiguous().view(Batchsize, -1)
+    y_true = F.one_hot(y_true, Channel)  # N,H*W -> N,H*W, C
+    y_true = y_true.permute(0, 2, 1)  # H, C, H*W
+    assert y_pred.size() == y_true.size()
+    smooth = 1e-5
+    eps = 1e-7
+    # remove backgroud region
+    y_pred_nobk = y_pred[:, 1:Channel, ...]
+    y_true_nobk = y_true[:, 1:Channel, ...]
+    intersection = torch.sum(y_true_nobk * y_pred_nobk, dim=(0, 2))
+    denominator = torch.sum(y_true_nobk + y_pred_nobk, dim=(0, 2))
+    gen_dice_coef = ((2. * intersection + smooth) / (denominator + smooth)).clamp_min(eps)
+    return gen_dice_coef.mean()
+
+
 def multiclass_iou_coeff(input: Tensor, target: Tensor):
     assert input.size() == target.size()
     union = 0

model/__pycache__/losses.cpython-36.pyc

@@ -77,7 +77,6 @@ def _accuracy_function(self, accuracyname, input, target):
                 return calc_accuracy(input, target)
             else:
                 input = torch.argmax(input, 1)
-                target = torch.argmax(target, 1)
                 return calc_accuracy(input, target)
 
     def trainprocess(self, trainimage, trainmask, validationimage, validationmask, model_dir, epochs=50, lr=1e-3):
@@ -88,7 +87,8 @@ def trainprocess(self, trainimage, trainmask, validationimage, validationmask, m
         print(self.model)
         # 1、initialize loss function and optimizer
         lossFunc = self._loss_function(self.loss_name)
-        opt = optim.Adam(self.model.parameters(), lr=lr)
+        opt = optim.Adam(self.model.parameters(), lr=lr, weight_decay=1e-4)
+        lr_scheduler = optim.lr_scheduler.ReduceLROnPlateau(opt, 'min', patience=2, verbose=True)
         # 2、load data train and validation dataset
         train_loader = self._dataloder(trainimage, trainmask, True)
         val_loader = self._dataloder(validationimage, validationmask)
@@ -154,6 +154,7 @@ def trainprocess(self, trainimage, trainmask, validationimage, validationmask, m
             avgValidationLoss = torch.mean(torch.stack(totalValidationLoss))
             avgTrainAccu = torch.mean(torch.stack(totalTrainAccu))
             avgValidationAccu = torch.mean(torch.stack(totalValiadtionAccu))
+            lr_scheduler.step(avgValidationLoss)
             # 4.6、update our training history
             H["train_loss"].append(avgTrainLoss.cpu().detach().numpy())
             H["valdation_loss"].append(avgValidationLoss.cpu().detach().numpy())
@@ -286,7 +287,6 @@ def _accuracy_function(self, accuracyname, input, target):
                 return calc_accuracy(input, target)
             else:
                 input = torch.argmax(input, 1)
-                target = torch.argmax(target, 1)
                 return calc_accuracy(input, target)
 
     def trainprocess(self, trainimage, trainmask, validationimage, validationmask, model_dir, epochs=50, lr=1e-3):
@@ -297,7 +297,8 @@ def trainprocess(self, trainimage, trainmask, validationimage, validationmask, m
         print(self.model)
         # 1、initialize loss function and optimizer
         lossFunc = self._loss_function(self.loss_name)
-        opt = optim.Adam(self.model.parameters(), lr=lr)
+        opt = optim.Adam(self.model.parameters(), lr=lr, weight_decay=1e-4)
+        lr_scheduler = optim.lr_scheduler.ReduceLROnPlateau(opt, 'min', patience=2, verbose=True)
         # 2、load data train and validation dataset
         train_loader = self._dataloder(trainimage, trainmask, True)
         val_loader = self._dataloder(validationimage, validationmask)
@@ -323,8 +324,6 @@ def trainprocess(self, trainimage, trainmask, validationimage, validationmask, m
                 # y should tensor with shape (N,C,W,H),
                 # if have mutil label y should one-hot,if only one label,the C is one
                 y = batch['label']
-                # one-hot encoding
-                y = F.one_hot(y, self.numclass)
                 # send the input to the device
                 x, y = x.to(self.device), y.to(self.device)
                 # perform a forward pass and calculate the training loss and accu
@@ -351,8 +350,6 @@ def trainprocess(self, trainimage, trainmask, validationimage, validationmask, m
                     x = batch['image']
                     # y should tensor with shape (N,)
                     y = batch['label']
-                    # one-hot encoding
-                    y = F.one_hot(y, self.numclass)
                     # send the input to the device
                     (x, y) = (x.to(self.device), y.to(self.device))
                     # make the predictions and calculate the validation loss
@@ -368,6 +365,7 @@ def trainprocess(self, trainimage, trainmask, validationimage, validationmask, m
             avgValidationLoss = torch.mean(torch.stack(totalValidationLoss))
             avgTrainAccu = torch.mean(torch.stack(totalTrainAccu))
             avgValidationAccu = torch.mean(torch.stack(totalValiadtionAccu))
+            lr_scheduler.step(avgValidationLoss)
             # 4.6、update our training history
             H["train_loss"].append(avgTrainLoss.cpu().detach().numpy())
             H["valdation_loss"].append(avgValidationLoss.cpu().detach().numpy())
@@ -502,7 +500,6 @@ def _accuracy_function(self, accuracyname, input, target):
                 return calc_accuracy(input, target)
             else:
                 input = torch.argmax(input, 1)
-                target = torch.argmax(target, 1)
                 return calc_accuracy(input, target)
 
     def trainprocess(self, trainimage, trainmask, validationimage, validationmask, model_dir, epochs=50, lr=1e-3):
@@ -513,7 +510,8 @@ def trainprocess(self, trainimage, trainmask, validationimage, validationmask, m
         print(self.model)
         # 1、initialize loss function and optimizer
         lossFunc = self._loss_function(self.loss_name)
-        opt = optim.Adam(self.model.parameters(), lr=lr)
+        opt = optim.Adam(self.model.parameters(), lr=lr, weight_decay=1e-4)
+        lr_scheduler = optim.lr_scheduler.ReduceLROnPlateau(opt, 'min', patience=2, verbose=True)
         # 2、load data train and validation dataset
         train_loader = self._dataloder(trainimage, trainmask, True)
         val_loader = self._dataloder(validationimage, validationmask)
@@ -579,6 +577,7 @@ def trainprocess(self, trainimage, trainmask, validationimage, validationmask, m
             avgValidationLoss = torch.mean(torch.stack(totalValidationLoss))
             avgTrainAccu = torch.mean(torch.stack(totalTrainAccu))
             avgValidationAccu = torch.mean(torch.stack(totalValiadtionAccu))
+            lr_scheduler.step(avgValidationLoss)
             # 4.6、update our training history
             H["train_loss"].append(avgTrainLoss.cpu().detach().numpy())
             H["valdation_loss"].append(avgValidationLoss.cpu().detach().numpy())
@@ -711,7 +710,6 @@ def _accuracy_function(self, accuracyname, input, target):
                 return calc_accuracy(input, target)
             else:
                 input = torch.argmax(input, 1)
-                target = torch.argmax(target, 1)
                 return calc_accuracy(input, target)
 
     def trainprocess(self, trainimage, trainmask, validationimage, validationmask, model_dir, epochs=50, lr=1e-3):
@@ -722,7 +720,8 @@ def trainprocess(self, trainimage, trainmask, validationimage, validationmask, m
         print(self.model)
         # 1、initialize loss function and optimizer
         lossFunc = self._loss_function(self.loss_name)
-        opt = optim.Adam(self.model.parameters(), lr=lr)
+        opt = optim.Adam(self.model.parameters(), lr=lr, weight_decay=1e-4)
+        lr_scheduler = optim.lr_scheduler.ReduceLROnPlateau(opt, 'min', patience=2, verbose=True)
         # 2、load data train and validation dataset
         train_loader = self._dataloder(trainimage, trainmask, True)
         val_loader = self._dataloder(validationimage, validationmask)
@@ -748,7 +747,6 @@ def trainprocess(self, trainimage, trainmask, validationimage, validationmask, m
                 # y should tensor with shape (N,C,W,H),
                 # if have mutil label y should one-hot,if only one label,the C is one
                 y = batch['label']
-                y = F.one_hot(y, self.numclass)
                 # send the input to the device
                 x, y = x.to(self.device), y.to(self.device)
                 # perform a forward pass and calculate the training loss and accu
@@ -775,7 +773,6 @@ def trainprocess(self, trainimage, trainmask, validationimage, validationmask, m
                     x = batch['image']
                     # y should tensor with shape (N,C,W,H)
                     y = batch['label']
-                    y = F.one_hot(y, self.numclass)
                     # send the input to the device
                     (x, y) = (x.to(self.device), y.to(self.device))
                     # make the predictions and calculate the validation loss
@@ -790,6 +787,7 @@ def trainprocess(self, trainimage, trainmask, validationimage, validationmask, m
             avgValidationLoss = torch.mean(torch.stack(totalValidationLoss))
             avgTrainAccu = torch.mean(torch.stack(totalTrainAccu))
             avgValidationAccu = torch.mean(torch.stack(totalValiadtionAccu))
+            lr_scheduler.step(avgValidationLoss)
             # 4.6、update our training history
             H["train_loss"].append(avgTrainLoss.cpu().detach().numpy())
             H["valdation_loss"].append(avgValidationLoss.cpu().detach().numpy())

model/__pycache__/lovasz.cpython-36.pyc

@@ -99,7 +99,8 @@ def trainprocess(self, trainimage, trainmask, validationimage, validationmask, m
             showpixelvalue = showpixelvalue // (self.numclass - 1)
         # 1、initialize loss function and optimizer
         lossFunc = self._loss_function(self.loss_name)
-        opt = optim.Adam(self.model.parameters(), lr=lr)
+        opt = optim.Adam(self.model.parameters(), lr=lr, weight_decay=1e-4)
+        lr_scheduler = optim.lr_scheduler.ReduceLROnPlateau(opt, 'min', patience=2, verbose=True)
         # 2、load data train and validation dataset
         train_loader = self._dataloder(trainimage, trainmask, True)
         val_loader = self._dataloder(validationimage, validationmask)
@@ -171,6 +172,7 @@ def trainprocess(self, trainimage, trainmask, validationimage, validationmask, m
             avgValidationLoss = torch.mean(torch.stack(totalValidationLoss))
             avgTrainAccu = torch.mean(torch.stack(totalTrainAccu))
             avgValidationAccu = torch.mean(torch.stack(totalValiadtionAccu))
+            lr_scheduler.step(avgValidationLoss)
             # 4.6、update our training history
             H["train_loss"].append(avgTrainLoss.cpu().detach().numpy())
             H["valdation_loss"].append(avgValidationLoss.cpu().detach().numpy())
@@ -316,7 +318,8 @@ def trainprocess(self, trainimage, trainmask, validationimage, validationmask, m
             showpixelvalue = showpixelvalue // (self.numclass - 1)
         # 1、initialize loss function and optimizer
         lossFunc = self._loss_function(self.loss_name)
-        opt = optim.Adam(self.model.parameters(), lr=lr)
+        opt = optim.Adam(self.model.parameters(), lr=lr, weight_decay=1e-4)
+        lr_scheduler = optim.lr_scheduler.ReduceLROnPlateau(opt, 'min', patience=2, verbose=True)
         # 2、load data train and validation dataset
         train_loader = self._dataloder(trainimage, trainmask, True)
         val_loader = self._dataloder(validationimage, validationmask)
@@ -342,13 +345,6 @@ def trainprocess(self, trainimage, trainmask, validationimage, validationmask, m
                 # y should tensor with shape (N,C,W,H),
                 # if have mutil label y should one-hot,if only one label,the C is one
                 y = batch['label']
-                # one-hot encoding
-                # y tensor with shape (N,W,H)
-                y = torch.squeeze(y, dim=1)
-                # y tensor with shape (N,W,H,C)
-                y = F.one_hot(y, self.numclass)
-                # y tensor with shape (N,C,W,H)
-                y = y.permute(0, 3, 1, 2)
                 # send the input to the device
                 x, y = x.to(self.device), y.to(self.device)
                 # perform a forward pass and calculate the training loss and accu
@@ -376,13 +372,6 @@ def trainprocess(self, trainimage, trainmask, validationimage, validationmask, m
                     x = batch['image']
                     # y should tensor with shape (N,C,W,H)
                     y = batch['label']
-                    # one-hot encoding
-                    # y tensor with shape (N,W,H)
-                    y = torch.squeeze(y, dim=1)
-                    # y tensor with shape (N,W,H,C)
-                    y = F.one_hot(y, self.numclass)
-                    # y tensor with shape (N,C,W,H)
-                    y = y.permute(0, 3, 1, 2)
                     # send the input to the device
                     (x, y) = (x.to(self.device), y.to(self.device))
                     # make the predictions and calculate the validation loss
@@ -399,6 +388,7 @@ def trainprocess(self, trainimage, trainmask, validationimage, validationmask, m
             avgValidationLoss = torch.mean(torch.stack(totalValidationLoss))
             avgTrainAccu = torch.mean(torch.stack(totalTrainAccu))
             avgValidationAccu = torch.mean(torch.stack(totalValiadtionAccu))
+            lr_scheduler.step(avgValidationLoss)
             # 4.6、update our training history
             H["train_loss"].append(avgTrainLoss.cpu().detach().numpy())
             H["valdation_loss"].append(avgValidationLoss.cpu().detach().numpy())
@@ -549,7 +539,8 @@ def trainprocess(self, trainimage, trainmask, validationimage, validationmask, m
             showpixelvalue = showpixelvalue // (self.numclass - 1)
         # 1、initialize loss function and optimizer
         lossFunc = self._loss_function(self.loss_name)
-        opt = optim.Adam(self.model.parameters(), lr=lr)
+        opt = optim.Adam(self.model.parameters(), lr=lr, weight_decay=1e-4)
+        lr_scheduler = optim.lr_scheduler.ReduceLROnPlateau(opt, 'min', patience=2, verbose=True)
         # 2、load data train and validation dataset
         train_loader = self._dataloder(trainimage, trainmask, True)
         val_loader = self._dataloder(validationimage, validationmask)
@@ -621,6 +612,7 @@ def trainprocess(self, trainimage, trainmask, validationimage, validationmask, m
             avgValidationLoss = torch.mean(torch.stack(totalValidationLoss))
             avgTrainAccu = torch.mean(torch.stack(totalTrainAccu))
             avgValidationAccu = torch.mean(torch.stack(totalValiadtionAccu))
+            lr_scheduler.step(avgValidationLoss)
             # 4.6、update our training history
             H["train_loss"].append(avgTrainLoss.cpu().detach().numpy())
             H["valdation_loss"].append(avgValidationLoss.cpu().detach().numpy())
@@ -780,7 +772,8 @@ def trainprocess(self, trainimage, trainmask, validationimage, validationmask, m
             showpixelvalue = showpixelvalue // (self.numclass - 1)
         # 1、initialize loss function and optimizer
         lossFunc = self._loss_function(self.loss_name)
-        opt = optim.AdamW(self.model.parameters(), lr=lr, weight_decay=1e-4)
+        opt = optim.Adam(self.model.parameters(), lr=lr, weight_decay=1e-4)
+        lr_scheduler = optim.lr_scheduler.ReduceLROnPlateau(opt, 'min', patience=2, verbose=True)
         # 2、load data train and validation dataset
         train_loader = self._dataloder(trainimage, trainmask, True)
         val_loader = self._dataloder(validationimage, validationmask)
@@ -848,6 +841,7 @@ def trainprocess(self, trainimage, trainmask, validationimage, validationmask, m
             avgValidationLoss = torch.mean(torch.stack(totalValidationLoss))
             avgTrainAccu = torch.mean(torch.stack(totalTrainAccu))
             avgValidationAccu = torch.mean(torch.stack(totalValiadtionAccu))
+            lr_scheduler.step(avgValidationLoss)
             # 4.6、update our training history
             H["train_loss"].append(avgTrainLoss.cpu().detach().numpy())
             H["valdation_loss"].append(avgValidationLoss.cpu().detach().numpy())