diff --git a/dygraph/paddleseg/core/seg_train.py b/dygraph/paddleseg/core/seg_train.py
index 01ed64e1999ddc36cfd42acb4db28094b50cbf35..ff9cdcbcd42b2553776a673302db8199cd1f9eaa 100644
--- a/dygraph/paddleseg/core/seg_train.py
+++ b/dygraph/paddleseg/core/seg_train.py
@@ -87,7 +87,8 @@ def seg_train(model,
     out_labels = ["loss", "reader_cost", "batch_cost"]
     base_logger = callbacks.BaseLogger(period=log_iters)
     train_logger = callbacks.TrainLogger(log_freq=log_iters)
-    model_ckpt = callbacks.ModelCheckpoint(save_dir, save_params_only=False, period=save_interval_iters)
+    model_ckpt = callbacks.ModelCheckpoint(
+        save_dir, save_params_only=False, period=save_interval_iters)
     vdl = callbacks.VisualDL(log_dir=os.path.join(save_dir, "log"))
     cbks_list = [base_logger, train_logger, model_ckpt, vdl]
 
@@ -120,7 +121,7 @@ def seg_train(model,
             iter += 1
             if iter > iters:
                 break
-            
+
             logs["reader_cost"] = timer.elapsed_time()
             ############## 2 ################
             cbks.on_iter_begin(iter, logs)
@@ -136,7 +137,7 @@ def seg_train(model,
                 loss = ddp_model.scale_loss(loss)
                 loss.backward()
                 ddp_model.apply_collective_grads()
-                
+
             else:
                 logits = model(images)
                 loss = loss_computation(logits, labels, losses)
@@ -148,7 +149,7 @@ def seg_train(model,
             model.clear_gradients()
 
             logs['loss'] = loss.numpy()[0]
-            
+
             logs["batch_cost"] = timer.elapsed_time()
 
             ############## 3 ################
@@ -159,4 +160,6 @@ def seg_train(model,
 
 ############### 4 ###############
     cbks.on_train_end(logs)
-#################################
\ No newline at end of file
+
+
+#################################
diff --git a/dygraph/paddleseg/core/val.py b/dygraph/paddleseg/core/val.py
index c104b2d8bf67419c58f15ba75989720662b0a2d8..b0f408c3b96f0040d8ca0882b701c7e56315c595 100644
--- a/dygraph/paddleseg/core/val.py
+++ b/dygraph/paddleseg/core/val.py
@@ -67,7 +67,7 @@ def evaluate(model,
         pred = pred[np.newaxis, :, :, np.newaxis]
         pred = pred.astype('int64')
         mask = label != ignore_index
-
+        # To-DO Test Execution Time
         conf_mat.calculate(pred=pred, label=label, ignore=mask)
         _, iou = conf_mat.mean_iou()
 
diff --git a/dygraph/paddleseg/cvlibs/callbacks.py b/dygraph/paddleseg/cvlibs/callbacks.py
index 952c97d843fcfd8fc198d5d09f61f7f58652ec6e..e948344ae499f333e435fa41fbd8f458cb8b3e2e 100644
--- a/dygraph/paddleseg/cvlibs/callbacks.py
+++ b/dygraph/paddleseg/cvlibs/callbacks.py
@@ -13,7 +13,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
 import os
 import time
 
@@ -24,6 +23,7 @@ from visualdl import LogWriter
 from paddleseg.utils.progbar import Progbar
 import paddleseg.utils.logger as logger
 
+
 class CallbackList(object):
     """Container abstracting a list of callbacks.
     # Arguments
@@ -44,7 +44,7 @@ class CallbackList(object):
     def set_model(self, model):
         for callback in self.callbacks:
             callback.set_model(model)
-    
+
     def set_optimizer(self, optimizer):
         for callback in self.callbacks:
             callback.set_optimizer(optimizer)
@@ -82,6 +82,7 @@ class CallbackList(object):
     def __iter__(self):
         return iter(self.callbacks)
 
+
 class Callback(object):
     """Abstract base class used to build new callbacks.
     """
@@ -94,7 +95,7 @@ class Callback(object):
 
     def set_model(self, model):
         self.model = model
-    
+
     def set_optimizer(self, optimizer):
         self.optimizer = optimizer
 
@@ -110,18 +111,18 @@ class Callback(object):
     def on_train_end(self, logs=None):
         pass
 
-class BaseLogger(Callback):
 
+class BaseLogger(Callback):
     def __init__(self, period=10):
         super(BaseLogger, self).__init__()
         self.period = period
-    
+
     def _reset(self):
         self.totals = {}
 
     def on_train_begin(self, logs=None):
         self.totals = {}
-    
+
     def on_iter_end(self, iter, logs=None):
         logs = logs or {}
         #(iter - 1) // iters_per_epoch + 1
@@ -132,13 +133,13 @@ class BaseLogger(Callback):
                 self.totals[k] = v
 
         if iter % self.period == 0 and ParallelEnv().local_rank == 0:
-            
+
             for k in self.totals:
                 logs[k] = self.totals[k] / self.period
             self._reset()
 
-class TrainLogger(Callback):
 
+class TrainLogger(Callback):
     def __init__(self, log_freq=10):
         self.log_freq = log_freq
 
@@ -154,7 +155,7 @@ class TrainLogger(Callback):
         return result.format(*arr)
 
     def on_iter_end(self, iter, logs=None):
-       
+
         if iter % self.log_freq == 0 and ParallelEnv().local_rank == 0:
             total_iters = self.params["total_iters"]
             iters_per_epoch = self.params["iters_per_epoch"]
@@ -167,49 +168,50 @@ class TrainLogger(Callback):
             reader_cost = logs["reader_cost"]
 
             logger.info(
-                "[TRAIN] epoch={}, iter={}/{}, loss={:.4f}, lr={:.6f}, batch_cost={:.4f}, reader_cost={:.4f} | ETA {}".
-                    format(current_epoch, iter, total_iters,
-                        loss, lr, batch_cost, reader_cost, eta))
+                "[TRAIN] epoch={}, iter={}/{}, loss={:.4f}, lr={:.6f}, batch_cost={:.4f}, reader_cost={:.4f} | ETA {}"
+                .format(current_epoch, iter, total_iters, loss, lr, batch_cost,
+                        reader_cost, eta))
 
-class ProgbarLogger(Callback):
 
+class ProgbarLogger(Callback):
     def __init__(self):
         super(ProgbarLogger, self).__init__()
 
     def on_train_begin(self, logs=None):
         self.verbose = self.params["verbose"]
         self.total_iters = self.params["total_iters"]
-        self.target = self.params["total_iters"] 
+        self.target = self.params["total_iters"]
         self.progbar = Progbar(target=self.target, verbose=self.verbose)
         self.seen = 0
         self.log_values = []
-    
+
     def on_iter_begin(self, iter, logs=None):
         #self.seen = 0
         if self.seen < self.target:
             self.log_values = []
-    
+
     def on_iter_end(self, iter, logs=None):
         logs = logs or {}
         self.seen += 1
         for k in self.params['metrics']:
             if k in logs:
                 self.log_values.append((k, logs[k]))
-        
+
         #if self.verbose and self.seen < self.target and ParallelEnv.local_rank == 0:
-            #print(self.log_values)
+        #print(self.log_values)
         if self.seen < self.target:
             self.progbar.update(self.seen, self.log_values)
-            
-        
-    
+
 
 class ModelCheckpoint(Callback):
+    def __init__(self,
+                 save_dir,
+                 monitor="miou",
+                 save_best_only=False,
+                 save_params_only=True,
+                 mode="max",
+                 period=1):
 
-    def __init__(self, save_dir, monitor="miou",
-                 save_best_only=False, save_params_only=True, 
-                 mode="max", period=1):
-        
         super(ModelCheckpoint, self).__init__()
         self.monitor = monitor
         self.save_dir = save_dir
@@ -241,7 +243,7 @@ class ModelCheckpoint(Callback):
         current_save_dir = os.path.join(self.save_dir, "iter_{}".format(iter))
         current_save_dir = os.path.abspath(current_save_dir)
         #if self.iters_since_last_save % self.period and ParallelEnv().local_rank == 0:
-            #self.iters_since_last_save = 0
+        #self.iters_since_last_save = 0
         if iter % self.period == 0 and ParallelEnv().local_rank == 0:
             if self.verbose > 0:
                 print("iter {iter_num}: saving model to {path}".format(
@@ -252,11 +254,9 @@ class ModelCheckpoint(Callback):
 
             if not self.save_params_only:
                 paddle.save(self.optimizer.state_dict(), filepath)
-    
 
 
 class VisualDL(Callback):
-
     def __init__(self, log_dir="./log", freq=1):
         super(VisualDL, self).__init__()
         self.log_dir = log_dir
@@ -274,4 +274,4 @@ class VisualDL(Callback):
         self.writer.flush()
 
     def on_train_end(self, logs=None):
-        self.writer.close()
\ No newline at end of file
+        self.writer.close()
diff --git a/dygraph/paddleseg/models/ann.py b/dygraph/paddleseg/models/ann.py
index d158d7f9023de5e8e1419bbf73996cb48c9904bf..f5d54487bc9d367569238700ba4aa763007fe8bf 100644
--- a/dygraph/paddleseg/models/ann.py
+++ b/dygraph/paddleseg/models/ann.py
@@ -28,7 +28,7 @@ class ANN(nn.Layer):
     """
     The ANN implementation based on PaddlePaddle.
 
-    The orginal artile refers to 
+    The original article refers to 
         Zhen, Zhu, et al. "Asymmetric Non-local Neural Networks for Semantic Segmentation."
         (https://arxiv.org/pdf/1908.07678.pdf)
 
@@ -37,8 +37,8 @@ class ANN(nn.Layer):
     Args:
         num_classes (int): the unique number of target classes.
         backbone (Paddle.nn.Layer): backbone network, currently support Resnet50/101.
-        model_pretrained (str): the path of pretrained model. Defaullt to None.
-        backbone_indices (tuple): two values in the tuple indicte the indices of output of backbone.
+        model_pretrained (str): the path of pretrained model. Default to None.
+        backbone_indices (tuple): two values in the tuple indicate the indices of output of backbone.
             the first index will be taken as low-level features; the second one will be 
             taken as high-level features in AFNB module. Usually backbone consists of four 
             downsampling stage, and return an output of each stage, so we set default (2, 3), 
@@ -48,7 +48,7 @@ class ANN(nn.Layer):
             Default to 256.
         inter_channels (int): both input and output channels of APNB modules.
         psp_size (tuple): the out size of pooled feature maps. Default to (1, 3, 6, 8).
-        enable_auxiliary_loss (bool): a bool values indictes whether adding auxiliary loss. Default to True.
+        enable_auxiliary_loss (bool): a bool values indicates whether adding auxiliary loss. Default to True.
     """
 
     def __init__(self,
@@ -79,7 +79,7 @@ class ANN(nn.Layer):
             psp_size=psp_size)
 
         self.context = nn.Sequential(
-            layer_libs.ConvBnRelu(
+            layer_libs.ConvBNReLU(
                 in_channels=high_in_channels,
                 out_channels=inter_channels,
                 kernel_size=3,
@@ -94,9 +94,7 @@ class ANN(nn.Layer):
                 psp_size=psp_size))
 
         self.cls = nn.Conv2d(
-            in_channels=inter_channels,
-            out_channels=num_classes,
-            kernel_size=1)
+            in_channels=inter_channels, out_channels=num_classes, kernel_size=1)
         self.auxlayer = layer_libs.AuxLayer(
             in_channels=low_in_channels,
             inter_channels=low_in_channels // 2,
@@ -122,7 +120,8 @@ class ANN(nn.Layer):
 
         if self.enable_auxiliary_loss:
             auxiliary_logit = self.auxlayer(low_level_x)
-            auxiliary_logit = F.resize_bilinear(auxiliary_logit, input.shape[2:])
+            auxiliary_logit = F.resize_bilinear(auxiliary_logit,
+                                                input.shape[2:])
             logit_list.append(auxiliary_logit)
 
         return logit_list
@@ -219,7 +218,7 @@ class APNB(nn.Layer):
             SelfAttentionBlock_APNB(in_channels, out_channels, key_channels,
                                     value_channels, size) for size in sizes
         ])
-        self.conv_bn = layer_libs.ConvBnRelu(
+        self.conv_bn = layer_libs.ConvBNReLU(
             in_channels=in_channels * 2,
             out_channels=out_channels,
             kernel_size=1)
@@ -280,11 +279,11 @@ class SelfAttentionBlock_AFNB(nn.Layer):
         if out_channels == None:
             self.out_channels = high_in_channels
         self.pool = nn.Pool2D(pool_size=(scale, scale), pool_type="max")
-        self.f_key = layer_libs.ConvBnRelu(
+        self.f_key = layer_libs.ConvBNReLU(
             in_channels=low_in_channels,
             out_channels=key_channels,
             kernel_size=1)
-        self.f_query = layer_libs.ConvBnRelu(
+        self.f_query = layer_libs.ConvBNReLU(
             in_channels=high_in_channels,
             out_channels=key_channels,
             kernel_size=1)
@@ -315,7 +314,7 @@ class SelfAttentionBlock_AFNB(nn.Layer):
         key = _pp_module(key, self.psp_size)
 
         sim_map = paddle.matmul(query, key)
-        sim_map = (self.key_channels ** -.5) * sim_map
+        sim_map = (self.key_channels**-.5) * sim_map
         sim_map = F.softmax(sim_map, axis=-1)
 
         context = paddle.matmul(sim_map, value)
@@ -358,7 +357,7 @@ class SelfAttentionBlock_APNB(nn.Layer):
         self.value_channels = value_channels
 
         self.pool = nn.Pool2D(pool_size=(scale, scale), pool_type="max")
-        self.f_key = layer_libs.ConvBnRelu(
+        self.f_key = layer_libs.ConvBNReLU(
             in_channels=self.in_channels,
             out_channels=self.key_channels,
             kernel_size=1)
@@ -384,15 +383,14 @@ class SelfAttentionBlock_APNB(nn.Layer):
         value = paddle.transpose(value, perm=(0, 2, 1))
 
         query = self.f_query(x)
-        query = paddle.reshape(
-            query, shape=(batch_size, self.key_channels, -1))
+        query = paddle.reshape(query, shape=(batch_size, self.key_channels, -1))
         query = paddle.transpose(query, perm=(0, 2, 1))
 
         key = self.f_key(x)
         key = _pp_module(key, self.psp_size)
 
         sim_map = paddle.matmul(query, key)
-        sim_map = (self.key_channels ** -.5) * sim_map
+        sim_map = (self.key_channels**-.5) * sim_map
         sim_map = F.softmax(sim_map, axis=-1)
 
         context = paddle.matmul(sim_map, value)
diff --git a/dygraph/paddleseg/models/backbones/resnet_vd.py b/dygraph/paddleseg/models/backbones/resnet_vd.py
index b9cae17e3672edafba99ec0dd32f5bd614e6ca89..38e2cf55a9967dc71c229a5293593ae33b33c926 100644
--- a/dygraph/paddleseg/models/backbones/resnet_vd.py
+++ b/dygraph/paddleseg/models/backbones/resnet_vd.py
@@ -133,8 +133,9 @@ class BottleneckBlock(nn.Layer):
         # If given dilation rate > 1, using corresponding padding
         if self.dilation > 1:
             padding = self.dilation
-            y = F.pad(y, [0, 0, 0, 0, padding, padding, padding, padding])
+            y = F.pad(y, [padding, padding, padding, padding])
         #####################################################################
+
         conv1 = self.conv1(y)
         conv2 = self.conv2(conv1)
 
@@ -197,11 +198,10 @@ class BasicBlock(nn.Layer):
 
 class ResNet_vd(nn.Layer):
     def __init__(self,
-                 backbone_pretrained=None,
                  layers=50,
-                 class_dim=1000,
                  output_stride=None,
-                 multi_grid=(1, 1, 1)):
+                 multi_grid=(1, 1, 1),
+                 pretrained=None):
         super(ResNet_vd, self).__init__()
 
         self.layers = layers
@@ -224,6 +224,10 @@ class ResNet_vd(nn.Layer):
                         ] if layers >= 50 else [64, 64, 128, 256]
         num_filters = [64, 128, 256, 512]
 
+        # for channels of returned stage
+        self.backbone_channels = [c * 4 for c in num_filters
+                                  ] if layers >= 50 else num_filters
+
         dilation_dict = None
         if output_stride == 8:
             dilation_dict = {2: 2, 3: 4}
@@ -315,6 +319,8 @@ class ResNet_vd(nn.Layer):
                     block_list.append(basic_block)
                     shortcut = True
                 self.stage_list.append(block_list)
+                
+        utils.load_pretrained_model(self, pretrained)
 
     def forward(self, inputs):
         y = self.conv1_1(inputs)
@@ -324,12 +330,14 @@ class ResNet_vd(nn.Layer):
 
         # A feature list saves the output feature map of each stage.
         feat_list = []
-        for i, stage in enumerate(self.stage_list):
-            for j, block in enumerate(stage):
+        for stage in self.stage_list:
+            for block in stage:
                 y = block(y)
             feat_list.append(y)
 
         return feat_list
+    
+
 
 
 @manager.BACKBONES.add_component
diff --git a/dygraph/paddleseg/models/common/pyramid_pool.py b/dygraph/paddleseg/models/common/pyramid_pool.py
index 2b8379577523668ff1eaddc8564bc72c399d085e..86a98b38625221db34eef765a000f91536ec4b72 100644
--- a/dygraph/paddleseg/models/common/pyramid_pool.py
+++ b/dygraph/paddleseg/models/common/pyramid_pool.py
@@ -13,7 +13,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
 import paddle
 from paddle import nn
 import paddle.nn.functional as F
@@ -34,11 +33,11 @@ class ASPPModule(nn.Layer):
         image_pooling: if augmented with image-level features.
     """
 
-    def __init__(self, 
-                 aspp_ratios, 
-                 in_channels, 
-                 out_channels, 
-                 sep_conv=False, 
+    def __init__(self,
+                 aspp_ratios,
+                 in_channels,
+                 out_channels,
+                 sep_conv=False,
                  image_pooling=False):
         super(ASPPModule, self).__init__()
 
@@ -47,42 +46,41 @@ class ASPPModule(nn.Layer):
         for ratio in aspp_ratios:
 
             if sep_conv and ratio > 1:
-                conv_func = layer_libs.DepthwiseConvBnRelu
+                conv_func = layer_libs.DepthwiseConvBNReLU
             else:
-                conv_func = layer_libs.ConvBnRelu
+                conv_func = layer_libs.ConvBNReLU
 
             block = conv_func(
                 in_channels=in_channels,
                 out_channels=out_channels,
                 kernel_size=1 if ratio == 1 else 3,
                 dilation=ratio,
-                padding=0 if ratio == 1 else ratio
-            )
+                padding=0 if ratio == 1 else ratio)
             self.aspp_blocks.append(block)
-        
+
         out_size = len(self.aspp_blocks)
 
         if image_pooling:
             self.global_avg_pool = nn.Sequential(
                 nn.AdaptiveAvgPool2d(output_size=(1, 1)),
-                layer_libs.ConvBnRelu(in_channels, out_channels, kernel_size=1, bias_attr=False)
-            )
+                layer_libs.ConvBNReLU(
+                    in_channels, out_channels, kernel_size=1, bias_attr=False))
             out_size += 1
         self.image_pooling = image_pooling
 
-        self.conv_bn_relu = layer_libs.ConvBnRelu(
-            in_channels=out_channels * out_size, 
-            out_channels=out_channels, 
+        self.conv_bn_relu = layer_libs.ConvBNReLU(
+            in_channels=out_channels * out_size,
+            out_channels=out_channels,
             kernel_size=1)
 
-        self.dropout = nn.Dropout(p=0.1) # drop rate
+        self.dropout = nn.Dropout(p=0.1)  # drop rate
 
     def forward(self, x):
 
         outputs = []
         for block in self.aspp_blocks:
             outputs.append(block(x))
-        
+
         if self.image_pooling:
             img_avg = self.global_avg_pool(x)
             img_avg = F.resize_bilinear(img_avg, out_shape=x.shape[2:])
@@ -93,17 +91,17 @@ class ASPPModule(nn.Layer):
         x = self.dropout(x)
 
         return x
-        
+
 
 class PPModule(nn.Layer):
     """
-    Pyramid pooling module orginally in PSPNet
+    Pyramid pooling module originally in PSPNet
 
     Args:
         in_channels (int): the number of intput channels to pyramid pooling module.
         out_channels (int): the number of output channels after pyramid pooling module.
         bin_sizes (tuple): the out size of pooled feature maps. Default to (1,2,3,6).
-        dim_reduction (bool): a bool value represent if reduing dimention after pooling. Default to True.
+        dim_reduction (bool): a bool value represent if reducing dimension after pooling. Default to True.
     """
 
     def __init__(self,
@@ -125,7 +123,7 @@ class PPModule(nn.Layer):
             for size in bin_sizes
         ])
 
-        self.conv_bn_relu2 = layer_libs.ConvBnRelu(
+        self.conv_bn_relu2 = layer_libs.ConvBNReLU(
             in_channels=in_channels + inter_channels * len(bin_sizes),
             out_channels=out_channels,
             kernel_size=3,
@@ -135,7 +133,7 @@ class PPModule(nn.Layer):
         """
         Create one pooling layer.
 
-        In our implementation, we adopt the same dimention reduction as the original paper that might be
+        In our implementation, we adopt the same dimension reduction as the original paper that might be
         slightly different with other implementations. 
 
         After pooling, the channels are reduced to 1/len(bin_sizes) immediately, while some other implementations
@@ -151,7 +149,7 @@ class PPModule(nn.Layer):
         """
 
         prior = nn.AdaptiveAvgPool2d(output_size=(size, size))
-        conv = layer_libs.ConvBnRelu(
+        conv = layer_libs.ConvBNReLU(
             in_channels=in_channels, out_channels=out_channels, kernel_size=1)
 
         return nn.Sequential(prior, conv)
@@ -167,4 +165,4 @@ class PPModule(nn.Layer):
         cat = paddle.concat(cat_layers, axis=1)
         out = self.conv_bn_relu2(cat)
 
-        return out
\ No newline at end of file
+        return out
diff --git a/dygraph/paddleseg/models/deeplab.py b/dygraph/paddleseg/models/deeplab.py
index 75a24f3081b0e5bb9703c77520521edf0a5a4819..920990ddaa0420dfefbee38cd858429ab3d1abe6 100644
--- a/dygraph/paddleseg/models/deeplab.py
+++ b/dygraph/paddleseg/models/deeplab.py
@@ -29,140 +29,193 @@ class DeepLabV3P(nn.Layer):
     """
     The DeepLabV3Plus implementation based on PaddlePaddle.
 
-    The orginal artile refers to
-    "Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation"
-     Liang-Chieh Chen, Yukun Zhu, George Papandreou, Florian Schroff, Hartwig Adam.
+    The original article refers to
+     Liang-Chieh Chen, et, al. "Encoder-Decoder with Atrous Separable Convolution for Semantic Image Segmentation"
      (https://arxiv.org/abs/1802.02611)
 
-     The DeepLabV3P consists of three main components, Backbone, ASPP and Decoder.
-
     Args:
         num_classes (int): the unique number of target classes.
-        backbone (paddle.nn.Layer): backbone network, currently support Xception65, Resnet101_vd.
-        model_pretrained (str): the path of pretrained model.
-        aspp_ratios (tuple): the dilation rate using in ASSP module.
-            if output_stride=16, aspp_ratios should be set as (1, 6, 12, 18).
-            if output_stride=8, aspp_ratios is (1, 12, 24, 36).
-        backbone_indices (tuple): two values in the tuple indicte the indices of output of backbone.
-            the first index will be taken as a low-level feature in Deconder component;
+        backbone (paddle.nn.Layer): backbone network, currently support Resnet50_vd/Resnet101_vd/Xception65.
+        backbone_indices (tuple): two values in the tuple indicate the indices of output of backbone.
+            the first index will be taken as a low-level feature in Decoder component;
             the second one will be taken as input of ASPP component.
             Usually backbone consists of four downsampling stage, and return an output of
             each stage, so we set default (0, 3), which means taking feature map of the first
             stage in backbone as low-level feature used in Decoder, and feature map of the fourth
             stage as input of ASPP.
-        backbone_channels (tuple): the same length with "backbone_indices". It indicates the channels of corresponding index.
+        aspp_ratios (tuple): the dilation rate using in ASSP module.
+            if output_stride=16, aspp_ratios should be set as (1, 6, 12, 18).
+            if output_stride=8, aspp_ratios is (1, 12, 24, 36).
+        aspp_out_channels (int): the output channels of ASPP module.
+        pretrained (str): the path of pretrained model for fine tuning.
+        
     """
 
     def __init__(self,
                  num_classes,
                  backbone,
-                 backbone_pretrained=None,
-                 model_pretrained=None,
                  backbone_indices=(0, 3),
-                 backbone_channels=(256, 2048),
                  aspp_ratios=(1, 6, 12, 18),
-                 aspp_out_channels=256):
+                 aspp_out_channels=256,
+                 pretrained=None):
 
         super(DeepLabV3P, self).__init__()
 
         self.backbone = backbone
-        self.backbone_pretrained = backbone_pretrained
-        self.model_pretrained = model_pretrained
+        backbone_channels = backbone.backbone_channels
+
+        self.head = DeepLabV3PHead(
+            num_classes,
+            backbone_indices,
+            backbone_channels,
+            aspp_ratios,
+            aspp_out_channels)
+
+        utils.load_entire_model(self, pretrained)
+
+    def forward(self, input):
+
+        feat_list = self.backbone(input)
+        logit_list = self.head(feat_list)
+        return [
+            F.resize_bilinear(logit, input.shape[2:]) for logit in logit_list
+        ]
+
+class DeepLabV3PHead(nn.Layer):
+    """
+    The DeepLabV3PHead implementation based on PaddlePaddle.
+
+    Args:
+        num_classes (int): the unique number of target classes.
+        backbone_indices (tuple): two values in the tuple indicate the indices of output of backbone.
+            the first index will be taken as a low-level feature in Decoder component;
+            the second one will be taken as input of ASPP component.
+            Usually backbone consists of four downsampling stage, and return an output of
+            each stage, so we set default (0, 3), which means taking feature map of the first
+            stage in backbone as low-level feature used in Decoder, and feature map of the fourth
+            stage as input of ASPP.
+        backbone_channels (tuple): returned channels of backbone
+        aspp_ratios (tuple): the dilation rate using in ASSP module.
+            if output_stride=16, aspp_ratios should be set as (1, 6, 12, 18).
+            if output_stride=8, aspp_ratios is (1, 12, 24, 36).
+        aspp_out_channels (int): the output channels of ASPP module.
+        
+    """
+
+    def __init__(self,
+                 num_classes,
+                 backbone_indices,
+                 backbone_channels,
+                 aspp_ratios=(1, 6, 12, 18),
+                 aspp_out_channels=256):
+
+        super(DeepLabV3PHead, self).__init__()
         
         self.aspp = pyramid_pool.ASPPModule(
-            aspp_ratios, backbone_channels[1], aspp_out_channels, sep_conv=True, image_pooling=True)
-        self.decoder = Decoder(num_classes, backbone_channels[0])
+            aspp_ratios,
+            backbone_channels[backbone_indices[1]],
+            aspp_out_channels,
+            sep_conv=True,
+            image_pooling=True)
+        self.decoder = Decoder(num_classes, backbone_channels[backbone_indices[0]])
         self.backbone_indices = backbone_indices
         self.init_weight()
 
-    def forward(self, input, label=None):
+    def forward(self, feat_list):
 
         logit_list = []
-        _, feat_list = self.backbone(input)
         low_level_feat = feat_list[self.backbone_indices[0]]
         x = feat_list[self.backbone_indices[1]]
         x = self.aspp(x)
         logit = self.decoder(x, low_level_feat)
-        logit = F.resize_bilinear(logit, input.shape[2:])
         logit_list.append(logit)
 
         return logit_list
 
     def init_weight(self):
-        """
-        Initialize the parameters of model parts.
-        Args:
-            pretrained_model ([str], optional): the path of pretrained model. Defaults to None.
-        """
-        if self.model_pretrained is not None:
-            utils.load_pretrained_model(self, self.model_pretrained)
-        elif self.backbone_pretrained is not None:
-            utils.load_pretrained_model(self.backbone, self.backbone_pretrained)
-           
+        pass
 
 @manager.MODELS.add_component
 class DeepLabV3(nn.Layer):
     """
     The DeepLabV3 implementation based on PaddlePaddle.
 
-    The orginal article refers to
-    "Rethinking Atrous Convolution for Semantic Image Segmentation"
-     Liang-Chieh Chen, George Papandreou, Florian Schroff, Hartwig Adam.
+    The original article refers to
+     Liang-Chieh Chen, et, al. "Rethinking Atrous Convolution for Semantic Image Segmentation"
      (https://arxiv.org/pdf/1706.05587.pdf)
 
     Args:
         Refer to DeepLabV3P above 
     """
-
+    
     def __init__(self,
                  num_classes,
                  backbone,
-                 backbone_pretrained=None,
-                 model_pretrained=None,
-                 backbone_indices=(3,),
-                 backbone_channels=(2048,),
+                 pretrained=None,
+                 backbone_indices=(3, ),
                  aspp_ratios=(1, 6, 12, 18),
                  aspp_out_channels=256):
 
         super(DeepLabV3, self).__init__()
 
         self.backbone = backbone
+        backbone_channels = backbone.backbone_channels
+
+        self.head = DeepLabV3Head(
+            num_classes,
+            backbone_indices,
+            backbone_channels,
+            aspp_ratios,
+            aspp_out_channels)
+        
+        utils.load_entire_model(self, pretrained)
+
+    def forward(self, input):
+
+        feat_list = self.backbone(input)
+        logit_list = self.head(feat_list)
+        return [
+            F.resize_bilinear(logit, input.shape[2:]) for logit in logit_list
+        ]
+
+
+class DeepLabV3Head(nn.Layer):
+    def __init__(self,
+                 num_classes,
+                 backbone_indices=(3, ),
+                 backbone_channels=(2048, ),
+                 aspp_ratios=(1, 6, 12, 18),
+                 aspp_out_channels=256):
+
+        super(DeepLabV3Head, self).__init__()
 
         self.aspp = pyramid_pool.ASPPModule(
-            aspp_ratios, backbone_channels[0], aspp_out_channels, 
-            sep_conv=False, image_pooling=True)
+            aspp_ratios,
+            backbone_channels[backbone_indices[0]],
+            aspp_out_channels,
+            sep_conv=False,
+            image_pooling=True)
 
         self.cls = nn.Conv2d(
-            in_channels=backbone_channels[0],
+            in_channels=backbone_channels[backbone_indices[0]],
             out_channels=num_classes,
             kernel_size=1)
 
         self.backbone_indices = backbone_indices
-        self.init_weight(model_pretrained)
+        self.init_weight()
 
-    def forward(self, input, label=None):
+    def forward(self, feat_list):
 
         logit_list = []
-        _, feat_list = self.backbone(input)
+
         x = feat_list[self.backbone_indices[0]]
         logit = self.cls(x)
-        logit = F.resize_bilinear(logit, input.shape[2:])
         logit_list.append(logit)
 
         return logit_list
 
-    def init_weight(self, pretrained_model=None):
-        """
-        Initialize the parameters of model parts.
-        Args:
-            pretrained_model ([str], optional): the path of pretrained model. Defaults to None.
-        """
-        if pretrained_model is not None:
-            if os.path.exists(pretrained_model):
-                utils.load_pretrained_model(self, pretrained_model)
-            else:
-                raise Exception('Pretrained model is not found: {}'.format(
-                    pretrained_model))
+    def init_weight(self):
+        pass
 
 
 class Decoder(nn.Layer):
@@ -178,12 +231,12 @@ class Decoder(nn.Layer):
     def __init__(self, num_classes, in_channels):
         super(Decoder, self).__init__()
 
-        self.conv_bn_relu1 = layer_libs.ConvBnRelu(
+        self.conv_bn_relu1 = layer_libs.ConvBNReLU(
             in_channels=in_channels, out_channels=48, kernel_size=1)
 
-        self.conv_bn_relu2 = layer_libs.DepthwiseConvBnRelu(
+        self.conv_bn_relu2 = layer_libs.DepthwiseConvBNReLU(
             in_channels=304, out_channels=256, kernel_size=3, padding=1)
-        self.conv_bn_relu3 = layer_libs.DepthwiseConvBnRelu(
+        self.conv_bn_relu3 = layer_libs.DepthwiseConvBNReLU(
             in_channels=256, out_channels=256, kernel_size=3, padding=1)
         self.conv = nn.Conv2d(
             in_channels=256, out_channels=num_classes, kernel_size=1)
diff --git a/dygraph/paddleseg/models/fast_scnn.py b/dygraph/paddleseg/models/fast_scnn.py
index f3d87493f0eead76e039ee5c5587cb9f340ca875..b88c91f24923ae0701e4731d72a4cf791bf37cbb 100644
--- a/dygraph/paddleseg/models/fast_scnn.py
+++ b/dygraph/paddleseg/models/fast_scnn.py
@@ -26,15 +26,15 @@ class FastSCNN(nn.Layer):
     As mentioned in the original paper, FastSCNN is a real-time segmentation algorithm (123.5fps) 
     even for high resolution images (1024x2048).
 
-    The orginal artile refers to 
+    The original article refers to 
         Poudel, Rudra PK, et al. "Fast-scnn: Fast semantic segmentation network."
         (https://arxiv.org/pdf/1902.04502.pdf)
 
     Args:
 
         num_classes (int): the unique number of target classes. Default to 2.
-        model_pretrained (str): the path of pretrained model. Defaullt to None.
-        enable_auxiliary_loss (bool): a bool values indictes whether adding auxiliary loss.
+        model_pretrained (str): the path of pretrained model. Default to None.
+        enable_auxiliary_loss (bool): a bool values indicates whether adding auxiliary loss.
             if true, auxiliary loss will be added after LearningToDownsample module, where the weight is 0.4. Default to False.
     """
 
@@ -105,15 +105,15 @@ class LearningToDownsample(nn.Layer):
     def __init__(self, dw_channels1=32, dw_channels2=48, out_channels=64):
         super(LearningToDownsample, self).__init__()
 
-        self.conv_bn_relu = layer_libs.ConvBnRelu(
+        self.conv_bn_relu = layer_libs.ConvBNReLU(
             in_channels=3, out_channels=dw_channels1, kernel_size=3, stride=2)
-        self.dsconv_bn_relu1 = layer_libs.DepthwiseConvBnRelu(
+        self.dsconv_bn_relu1 = layer_libs.DepthwiseConvBNReLU(
             in_channels=dw_channels1,
             out_channels=dw_channels2,
             kernel_size=3,
             stride=2,
             padding=1)
-        self.dsconv_bn_relu2 = layer_libs.DepthwiseConvBnRelu(
+        self.dsconv_bn_relu2 = layer_libs.DepthwiseConvBNReLU(
             in_channels=dw_channels2,
             out_channels=out_channels,
             kernel_size=3,
@@ -208,13 +208,13 @@ class LinearBottleneck(nn.Layer):
         expand_channels = in_channels * expansion
         self.block = nn.Sequential(
             # pw
-            layer_libs.ConvBnRelu(
+            layer_libs.ConvBNReLU(
                 in_channels=in_channels,
                 out_channels=expand_channels,
                 kernel_size=1,
                 bias_attr=False),
             # dw
-            layer_libs.ConvBnRelu(
+            layer_libs.ConvBNReLU(
                 in_channels=expand_channels,
                 out_channels=expand_channels,
                 kernel_size=3,
@@ -239,7 +239,7 @@ class LinearBottleneck(nn.Layer):
 
 class FeatureFusionModule(nn.Layer):
     """
-    Feature Fusion Module Implememtation.
+    Feature Fusion Module Implementation.
 
     This module fuses high-resolution feature and low-resolution feature.
 
@@ -253,7 +253,7 @@ class FeatureFusionModule(nn.Layer):
         super(FeatureFusionModule, self).__init__()
 
         # There only depth-wise conv is used WITHOUT point-wise conv
-        self.dwconv = layer_libs.ConvBnRelu(
+        self.dwconv = layer_libs.ConvBNReLU(
             in_channels=low_in_channels,
             out_channels=out_channels,
             kernel_size=3,
@@ -301,13 +301,13 @@ class Classifier(nn.Layer):
     def __init__(self, input_channels, num_classes):
         super(Classifier, self).__init__()
 
-        self.dsconv1 = layer_libs.DepthwiseConvBnRelu(
+        self.dsconv1 = layer_libs.DepthwiseConvBNReLU(
             in_channels=input_channels,
             out_channels=input_channels,
             kernel_size=3,
             padding=1)
 
-        self.dsconv2 = layer_libs.DepthwiseConvBnRelu(
+        self.dsconv2 = layer_libs.DepthwiseConvBNReLU(
             in_channels=input_channels,
             out_channels=input_channels,
             kernel_size=3,
diff --git a/dygraph/paddleseg/models/gcnet.py b/dygraph/paddleseg/models/gcnet.py
index 670f08fd1300ddfa767cc1a7442251e38731dcaf..02d60a62077afd949ad8d8e99b667e71442105e9 100644
--- a/dygraph/paddleseg/models/gcnet.py
+++ b/dygraph/paddleseg/models/gcnet.py
@@ -27,15 +27,15 @@ class GCNet(nn.Layer):
     """
     The GCNet implementation based on PaddlePaddle.
 
-    The orginal artile refers to 
+    The original article refers to 
         Cao, Yue, et al. "GCnet: Non-local networks meet squeeze-excitation networks and beyond."
         (https://arxiv.org/pdf/1904.11492.pdf)
 
     Args:
         num_classes (int): the unique number of target classes.
         backbone (Paddle.nn.Layer): backbone network, currently support Resnet50/101.
-        model_pretrained (str): the path of pretrained model. Defaullt to None.
-        backbone_indices (tuple): two values in the tuple indicte the indices of output of backbone.
+        model_pretrained (str): the path of pretrained model. Default to None.
+        backbone_indices (tuple): two values in the tuple indicate the indices of output of backbone.
             the first index will be taken as a deep-supervision feature in auxiliary layer;
             the second one will be taken as input of GlobalContextBlock. Usually backbone 
             consists of four downsampling stage, and return an output of each stage, so we 
@@ -43,8 +43,8 @@ class GCNet(nn.Layer):
             and the fourth stage (res5c) in backbone.
         backbone_channels (tuple): the same length with "backbone_indices". It indicates the channels of corresponding index.
         gc_channels (int): input channels to Global Context Block. Default to 512.
-        ratio (float): it indictes the ratio of attention channels and gc_channels. Default to 1/4.
-        enable_auxiliary_loss (bool): a bool values indictes whether adding auxiliary loss. Default to True.
+        ratio (float): it indicates the ratio of attention channels and gc_channels. Default to 1/4.
+        enable_auxiliary_loss (bool): a bool values indicates whether adding auxiliary loss. Default to True.
     """
 
     def __init__(self,
@@ -63,7 +63,7 @@ class GCNet(nn.Layer):
         self.backbone = backbone
 
         in_channels = backbone_channels[1]
-        self.conv_bn_relu1 = layer_libs.ConvBnRelu(
+        self.conv_bn_relu1 = layer_libs.ConvBNReLU(
             in_channels=in_channels,
             out_channels=gc_channels,
             kernel_size=3,
@@ -71,13 +71,13 @@ class GCNet(nn.Layer):
 
         self.gc_block = GlobalContextBlock(in_channels=gc_channels, ratio=ratio)
 
-        self.conv_bn_relu2 = layer_libs.ConvBnRelu(
+        self.conv_bn_relu2 = layer_libs.ConvBNReLU(
             in_channels=gc_channels,
             out_channels=gc_channels,
             kernel_size=3,
             padding=1)
 
-        self.conv_bn_relu3 = layer_libs.ConvBnRelu(
+        self.conv_bn_relu3 = layer_libs.ConvBNReLU(
             in_channels=in_channels + gc_channels,
             out_channels=gc_channels,
             kernel_size=3,
@@ -154,7 +154,7 @@ class GlobalContextBlock(nn.Layer):
             in_channels=in_channels, out_channels=1, kernel_size=1)
 
         self.softmax = nn.Softmax(axis=2)
-        
+
         inter_channels = int(in_channels * ratio)
         self.channel_add_conv = nn.Sequential(
             nn.Conv2d(
diff --git a/dygraph/paddleseg/models/ocrnet.py b/dygraph/paddleseg/models/ocrnet.py
index f571c8c5b2ab5bb41cfc8e5bcadb3b229537ea6e..01f7214b7077ba17f6c5bf361783af6cc58bdb8d 100644
--- a/dygraph/paddleseg/models/ocrnet.py
+++ b/dygraph/paddleseg/models/ocrnet.py
@@ -124,7 +124,6 @@ class ObjectAttentionBlock(nn.Layer):
 class OCRHead(nn.Layer):
     """
     The Object contextual representation head.
-
     Args:
         num_classes(int): the unique number of target classes.
         in_channels(tuple): the number of input channels.
@@ -179,11 +178,9 @@ class OCRHead(nn.Layer):
 class OCRNet(nn.Layer):
     """
     The OCRNet implementation based on PaddlePaddle.
-
     The original article refers to
         Yuan, Yuhui, et al. "Object-Contextual Representations for Semantic Segmentation"
         (https://arxiv.org/pdf/1909.11065.pdf)
-
     Args:
         num_classes(int): the unique number of target classes.
         backbone(Paddle.nn.Layer): backbone network.
@@ -234,4 +231,4 @@ class OCRNet(nn.Layer):
                 utils.load_pretrained_model(self, pretrained)
             else:
                 raise Exception(
-                    'Pretrained model is not found: {}'.format(pretrained))
+                    'Pretrained model is not found: {}'.format(pretrained))
\ No newline at end of file
diff --git a/dygraph/paddleseg/models/pspnet.py b/dygraph/paddleseg/models/pspnet.py
index 74436068ae064c18716f01a8b49278169ea4772f..12436d149d89fa8e05ce49157a46483e2cb6ab43 100644
--- a/dygraph/paddleseg/models/pspnet.py
+++ b/dygraph/paddleseg/models/pspnet.py
@@ -26,7 +26,7 @@ class PSPNet(nn.Layer):
     """
     The PSPNet implementation based on PaddlePaddle.
 
-    The orginal artile refers to
+    The original article refers to
         Zhao, Hengshuang, et al. "Pyramid scene parsing network."
         Proceedings of the IEEE conference on computer vision and pattern recognition. 2017.
         (https://openaccess.thecvf.com/content_cvpr_2017/papers/Zhao_Pyramid_Scene_Parsing_CVPR_2017_paper.pdf)
@@ -34,8 +34,8 @@ class PSPNet(nn.Layer):
     Args:
         num_classes (int): the unique number of target classes.
         backbone (Paddle.nn.Layer): backbone network, currently support Resnet50/101.
-        model_pretrained (str): the path of pretrained model. Defaullt to None.
-        backbone_indices (tuple): two values in the tuple indicte the indices of output of backbone.
+        model_pretrained (str): the path of pretrained model. Default to None.
+        backbone_indices (tuple): two values in the tuple indicate the indices of output of backbone.
                         the first index will be taken as a deep-supervision feature in auxiliary layer;
                         the second one will be taken as input of Pyramid Pooling Module (PPModule).
                         Usually backbone consists of four downsampling stage, and return an output of
@@ -44,7 +44,7 @@ class PSPNet(nn.Layer):
         backbone_channels (tuple): the same length with "backbone_indices". It indicates the channels of corresponding index.
         pp_out_channels (int): output channels after Pyramid Pooling Module. Default to 1024.
         bin_sizes (tuple): the out size of pooled feature maps. Default to (1,2,3,6).
-        enable_auxiliary_loss (bool): a bool values indictes whether adding auxiliary loss. Default to True.
+        enable_auxiliary_loss (bool): a bool values indicates whether adding auxiliary loss. Default to True.
     """
 
     def __init__(self,
@@ -107,6 +107,7 @@ class PSPNet(nn.Layer):
     def init_weight(self, pretrained_model=None):
         """
         Initialize the parameters of model parts.
+        
         Args:
             pretrained_model ([str], optional): the path of pretrained model. Defaults to None.
         """
diff --git a/dygraph/paddleseg/utils/metrics.py b/dygraph/paddleseg/utils/metrics.py
index b107cbd57a936fb909086567fc8b703fb86963b7..44eaf4ed0580699cdb0be35f53a343cb8f70b751 100644
--- a/dygraph/paddleseg/utils/metrics.py
+++ b/dygraph/paddleseg/utils/metrics.py
@@ -41,7 +41,7 @@ class ConfusionMatrix(object):
         label = np.asarray(label)[mask]
         pred = np.asarray(pred)[mask]
         one = np.ones_like(pred)
-        # Accumuate ([row=label, col=pred], 1) into sparse matrix
+        # Accumuate ([row=label, col=pred], 1) into sparse
         spm = csr_matrix((one, (label, pred)),
                          shape=(self.num_classes, self.num_classes))
         spm = spm.todense()
diff --git a/dygraph/paddleseg/utils/progbar.py b/dygraph/paddleseg/utils/progbar.py
index b5e82881abe238f2eb686e8dfd28214f70b97819..d57ce707c407b7837acb9cbd4d2ad244ff6575a7 100644
--- a/dygraph/paddleseg/utils/progbar.py
+++ b/dygraph/paddleseg/utils/progbar.py
@@ -17,8 +17,9 @@ import time
 
 import numpy as np
 
+
 class Progbar(object):
-  """Displays a progress bar.
+    """Displays a progress bar.
      refers to https://github.com/keras-team/keras/blob/keras-2/keras/utils/generic_utils.py
   Arguments:
       target: Total number of steps expected, None if unknown.
@@ -31,39 +32,39 @@ class Progbar(object):
       unit_name: Display name for step counts (usually "step" or "sample").
   """
 
-  def __init__(self,
-               target,
-               width=30,
-               verbose=1,
-               interval=0.05,
-               stateful_metrics=None,
-               unit_name='step'):
-    self.target = target
-    self.width = width
-    self.verbose = verbose
-    self.interval = interval
-    self.unit_name = unit_name
-    if stateful_metrics:
-      self.stateful_metrics = set(stateful_metrics)
-    else:
-      self.stateful_metrics = set()
-
-    self._dynamic_display = ((hasattr(sys.stdout, 'isatty') and
-                              sys.stdout.isatty()) or
-                             'ipykernel' in sys.modules or
-                             'posix' in sys.modules or
-                             'PYCHARM_HOSTED' in os.environ)
-    self._total_width = 0
-    self._seen_so_far = 0
-    # We use a dict + list to avoid garbage collection
-    # issues found in OrderedDict
-    self._values = {}
-    self._values_order = []
-    self._start = time.time()
-    self._last_update = 0
-
-  def update(self, current, values=None, finalize=None):
-    """Updates the progress bar.
+    def __init__(self,
+                 target,
+                 width=30,
+                 verbose=1,
+                 interval=0.05,
+                 stateful_metrics=None,
+                 unit_name='step'):
+        self.target = target
+        self.width = width
+        self.verbose = verbose
+        self.interval = interval
+        self.unit_name = unit_name
+        if stateful_metrics:
+            self.stateful_metrics = set(stateful_metrics)
+        else:
+            self.stateful_metrics = set()
+
+        self._dynamic_display = ((hasattr(sys.stdout, 'isatty')
+                                  and sys.stdout.isatty())
+                                 or 'ipykernel' in sys.modules
+                                 or 'posix' in sys.modules
+                                 or 'PYCHARM_HOSTED' in os.environ)
+        self._total_width = 0
+        self._seen_so_far = 0
+        # We use a dict + list to avoid garbage collection
+        # issues found in OrderedDict
+        self._values = {}
+        self._values_order = []
+        self._start = time.time()
+        self._last_update = 0
+
+    def update(self, current, values=None, finalize=None):
+        """Updates the progress bar.
     Arguments:
         current: Index of current step.
         values: List of tuples: `(name, value_for_last_step)`. If `name` is in
@@ -72,129 +73,131 @@ class Progbar(object):
         finalize: Whether this is the last update for the progress bar. If
           `None`, defaults to `current >= self.target`.
     """
-    if finalize is None:
-      if self.target is None:
-        finalize = False
-      else:
-        finalize = current >= self.target
-
-    values = values or []
-    for k, v in values:
-      if k not in self._values_order:
-        self._values_order.append(k)
-      if k not in self.stateful_metrics:
-        # In the case that progress bar doesn't have a target value in the first
-        # epoch, both on_batch_end and on_epoch_end will be called, which will
-        # cause 'current' and 'self._seen_so_far' to have the same value. Force
-        # the minimal value to 1 here, otherwise stateful_metric will be 0s.
-        value_base = max(current - self._seen_so_far, 1)
-        if k not in self._values:
-          self._values[k] = [v * value_base, value_base]
-        else:
-          self._values[k][0] += v * value_base
-          self._values[k][1] += value_base
-      else:
-        # Stateful metrics output a numeric value. This representation
-        # means "take an average from a single value" but keeps the
-        # numeric formatting.
-        self._values[k] = [v, 1]
-    self._seen_so_far = current
-
-    now = time.time()
-    info = ' - %.0fs' % (now - self._start)
-    if self.verbose == 1:
-      if now - self._last_update < self.interval and not finalize:
-        return
-
-      prev_total_width = self._total_width
-      if self._dynamic_display:
-        sys.stdout.write('\b' * prev_total_width)
-        sys.stdout.write('\r')
-      else:
-        sys.stdout.write('\n')
-
-      if self.target is not None:
-        numdigits = int(np.log10(self.target)) + 1
-        bar = ('%' + str(numdigits) + 'd/%d [') % (current, self.target)
-        prog = float(current) / self.target
-        prog_width = int(self.width * prog)
-        if prog_width > 0:
-          bar += ('=' * (prog_width - 1))
-          if current < self.target:
-            bar += '>'
-          else:
-            bar += '='
-        bar += ('.' * (self.width - prog_width))
-        bar += ']'
-      else:
-        bar = '%7d/Unknown' % current
-
-      self._total_width = len(bar)
-      sys.stdout.write(bar)
-
-      if current:
-        time_per_unit = (now - self._start) / current
-      else:
-        time_per_unit = 0
-
-      if self.target is None or finalize:
-        if time_per_unit >= 1 or time_per_unit == 0:
-          info += ' %.0fs/%s' % (time_per_unit, self.unit_name)
-        elif time_per_unit >= 1e-3:
-          info += ' %.0fms/%s' % (time_per_unit * 1e3, self.unit_name)
-        else:
-          info += ' %.0fus/%s' % (time_per_unit * 1e6, self.unit_name)
-      else:
-        eta = time_per_unit * (self.target - current)
-        if eta > 3600:
-          eta_format = '%d:%02d:%02d' % (eta // 3600,
-                                         (eta % 3600) // 60, eta % 60)
-        elif eta > 60:
-          eta_format = '%d:%02d' % (eta // 60, eta % 60)
-        else:
-          eta_format = '%ds' % eta
-
-        info = ' - ETA: %s' % eta_format
-
-      for k in self._values_order:
-        info += ' - %s:' % k
-        if isinstance(self._values[k], list):
-          avg = np.mean(self._values[k][0] / max(1, self._values[k][1]))
-          if abs(avg) > 1e-3:
-            info += ' %.4f' % avg
-          else:
-            info += ' %.4e' % avg
-        else:
-          info += ' %s' % self._values[k]
-
-      self._total_width += len(info)
-      if prev_total_width > self._total_width:
-        info += (' ' * (prev_total_width - self._total_width))
-
-      if finalize:
-        info += '\n'
-
-      sys.stdout.write(info)
-      sys.stdout.flush()
-
-    elif self.verbose == 2:
-      if finalize:
-        numdigits = int(np.log10(self.target)) + 1
-        count = ('%' + str(numdigits) + 'd/%d') % (current, self.target)
-        info = count + info
-        for k in self._values_order:
-          info += ' - %s:' % k
-          avg = np.mean(self._values[k][0] / max(1, self._values[k][1]))
-          if avg > 1e-3:
-            info += ' %.4f' % avg
-          else:
-            info += ' %.4e' % avg
-        info += '\n'
-
-        sys.stdout.write(info)
-        sys.stdout.flush()
-
-    self._last_update = now
-
-  def add(self, n, values=None):
-    self.update(self._seen_so_far + n, values)
\ No newline at end of file
+        if finalize is None:
+            if self.target is None:
+                finalize = False
+            else:
+                finalize = current >= self.target
+
+        values = values or []
+        for k, v in values:
+            if k not in self._values_order:
+                self._values_order.append(k)
+            if k not in self.stateful_metrics:
+                # In the case that progress bar doesn't have a target value in the first
+                # epoch, both on_batch_end and on_epoch_end will be called, which will
+                # cause 'current' and 'self._seen_so_far' to have the same value. Force
+                # the minimal value to 1 here, otherwise stateful_metric will be 0s.
+                value_base = max(current - self._seen_so_far, 1)
+                if k not in self._values:
+                    self._values[k] = [v * value_base, value_base]
+                else:
+                    self._values[k][0] += v * value_base
+                    self._values[k][1] += value_base
+            else:
+                # Stateful metrics output a numeric value. This representation
+                # means "take an average from a single value" but keeps the
+                # numeric formatting.
+                self._values[k] = [v, 1]
+        self._seen_so_far = current
+
+        now = time.time()
+        info = ' - %.0fs' % (now - self._start)
+        if self.verbose == 1:
+            if now - self._last_update < self.interval and not finalize:
+                return
+
+            prev_total_width = self._total_width
+            if self._dynamic_display:
+                sys.stdout.write('\b' * prev_total_width)
+                sys.stdout.write('\r')
+            else:
+                sys.stdout.write('\n')
+
+            if self.target is not None:
+                numdigits = int(np.log10(self.target)) + 1
+                bar = ('%' + str(numdigits) + 'd/%d [') % (current, self.target)
+                prog = float(current) / self.target
+                prog_width = int(self.width * prog)
+                if prog_width > 0:
+                    bar += ('=' * (prog_width - 1))
+                    if current < self.target:
+                        bar += '>'
+                    else:
+                        bar += '='
+                bar += ('.' * (self.width - prog_width))
+                bar += ']'
+            else:
+                bar = '%7d/Unknown' % current
+
+            self._total_width = len(bar)
+            sys.stdout.write(bar)
+
+            if current:
+                time_per_unit = (now - self._start) / current
+            else:
+                time_per_unit = 0
+
+            if self.target is None or finalize:
+                if time_per_unit >= 1 or time_per_unit == 0:
+                    info += ' %.0fs/%s' % (time_per_unit, self.unit_name)
+                elif time_per_unit >= 1e-3:
+                    info += ' %.0fms/%s' % (time_per_unit * 1e3, self.unit_name)
+                else:
+                    info += ' %.0fus/%s' % (time_per_unit * 1e6, self.unit_name)
+            else:
+                eta = time_per_unit * (self.target - current)
+                if eta > 3600:
+                    eta_format = '%d:%02d:%02d' % (eta // 3600,
+                                                   (eta % 3600) // 60, eta % 60)
+                elif eta > 60:
+                    eta_format = '%d:%02d' % (eta // 60, eta % 60)
+                else:
+                    eta_format = '%ds' % eta
+
+                info = ' - ETA: %s' % eta_format
+
+            for k in self._values_order:
+                info += ' - %s:' % k
+                if isinstance(self._values[k], list):
+                    avg = np.mean(
+                        self._values[k][0] / max(1, self._values[k][1]))
+                    if abs(avg) > 1e-3:
+                        info += ' %.4f' % avg
+                    else:
+                        info += ' %.4e' % avg
+                else:
+                    info += ' %s' % self._values[k]
+
+            self._total_width += len(info)
+            if prev_total_width > self._total_width:
+                info += (' ' * (prev_total_width - self._total_width))
+
+            if finalize:
+                info += '\n'
+
+            sys.stdout.write(info)
+            sys.stdout.flush()
+
+        elif self.verbose == 2:
+            if finalize:
+                numdigits = int(np.log10(self.target)) + 1
+                count = ('%' + str(numdigits) + 'd/%d') % (current, self.target)
+                info = count + info
+                for k in self._values_order:
+                    info += ' - %s:' % k
+                    avg = np.mean(
+                        self._values[k][0] / max(1, self._values[k][1]))
+                    if avg > 1e-3:
+                        info += ' %.4f' % avg
+                    else:
+                        info += ' %.4e' % avg
+                info += '\n'
+
+                sys.stdout.write(info)
+                sys.stdout.flush()
+
+        self._last_update = now
+
+    def add(self, n, values=None):
+        self.update(self._seen_so_far + n, values)
diff --git a/dygraph/paddleseg/utils/utils.py b/dygraph/paddleseg/utils/utils.py
index 02f7d3b7f9b9f3c8f2674e8ee0dcf7f52730b236..853773606af4d4c5bc996d98a5740b090688dc63 100644
--- a/dygraph/paddleseg/utils/utils.py
+++ b/dygraph/paddleseg/utils/utils.py
@@ -44,6 +44,19 @@ def seconds_to_hms(seconds):
     return hms_str
 
 
+def load_entire_model(model, pretrained):
+
+    if pretrained is not None:
+        if os.path.exists(pretrained):
+            load_pretrained_model(model, pretrained)
+        else:
+            raise Exception('Pretrained model is not found: {}'.format(
+                pretrained))
+    else:
+        logger.warning('Not all pretrained params of {} to load, '\
+             'training from scratch or a pretrained backbone'.format(model.__class__.__name__))
+
+
 def load_pretrained_model(model, pretrained_model):
     if pretrained_model is not None:
         logger.info('Load pretrained model from {}'.format(pretrained_model))
@@ -82,7 +95,7 @@ def load_pretrained_model(model, pretrained_model):
                     model_state_dict[k] = para_state_dict[k]
                     num_params_loaded += 1
             model.set_dict(model_state_dict)
-            logger.info("There are {}/{} varaibles are loaded.".format(
+            logger.info("There are {}/{} variables are loaded.".format(
                 num_params_loaded, len(model_state_dict)))
 
         else: