Optimizer parameters,Improve yolov3_darknet53 network precision

model_zoo/official/cv/yolov3_darknet53/scripts/run_distribute_train.sh

@@ -72,7 +72,9 @@ do
         --data_dir=$DATASET_PATH \
         --pretrained_backbone=$PRETRAINED_BACKBONE \
         --is_distributed=1 \
-        --lr=0.1 \
+        --lr=0.001 \
+        --loss_scale=1024 \
+        --weight_decay=0.016 \
         --T_max=320 \
         --max_epoch=320 \
         --warmup_epochs=4 \

model_zoo/official/cv/yolov3_darknet53/scripts/run_standalone_train.sh

@@ -65,7 +65,9 @@ python train.py \
     --data_dir=$DATASET_PATH \
     --pretrained_backbone=$PRETRAINED_BACKBONE \
     --is_distributed=0 \
-    --lr=0.1 \
+    --lr=0.001 \
+    --loss_scale=1024 \
+    --weight_decay=0.016 \
     --T_max=320 \
     --max_epoch=320 \
     --warmup_epochs=4 \

model_zoo/official/cv/yolov3_darknet53/src/util.py

@@ -13,8 +13,7 @@
 # limitations under the License.
 # ============================================================================
 """Util class or function."""
-from mindspore.train.serialization import load_checkpoint
-import mindspore.nn as nn
+from mindspore.train.serialization import load_checkpoint, load_param_into_net
 import mindspore.common.dtype as mstype
 
 from .yolo import YoloLossBlock
@@ -57,58 +56,18 @@ class AverageMeter:
 def load_backbone(net, ckpt_path, args):
     """Load darknet53 backbone checkpoint."""
     param_dict = load_checkpoint(ckpt_path)
-    yolo_backbone_prefix = 'feature_map.backbone'
-    darknet_backbone_prefix = 'network.backbone'
-    find_param = []
-    not_found_param = []
     net.init_parameters_data()
-    for name, cell in net.cells_and_names():
-        if name.startswith(yolo_backbone_prefix):
-            name = name.replace(yolo_backbone_prefix, darknet_backbone_prefix)
-            if isinstance(cell, (nn.Conv2d, nn.Dense)):
-                darknet_weight = '{}.weight'.format(name)
-                darknet_bias = '{}.bias'.format(name)
-                if darknet_weight in param_dict:
-                    cell.weight.set_data(param_dict[darknet_weight].data)
-                    find_param.append(darknet_weight)
-                else:
-                    not_found_param.append(darknet_weight)
-                if darknet_bias in param_dict:
-                    cell.bias.set_data(param_dict[darknet_bias].data)
-                    find_param.append(darknet_bias)
-                else:
-                    not_found_param.append(darknet_bias)
-            elif isinstance(cell, (nn.BatchNorm2d, nn.BatchNorm1d)):
-                darknet_moving_mean = '{}.moving_mean'.format(name)
-                darknet_moving_variance = '{}.moving_variance'.format(name)
-                darknet_gamma = '{}.gamma'.format(name)
-                darknet_beta = '{}.beta'.format(name)
-                if darknet_moving_mean in param_dict:
-                    cell.moving_mean.set_data(param_dict[darknet_moving_mean].data)
-                    find_param.append(darknet_moving_mean)
-                else:
-                    not_found_param.append(darknet_moving_mean)
-                if darknet_moving_variance in param_dict:
-                    cell.moving_variance.set_data(param_dict[darknet_moving_variance].data)
-                    find_param.append(darknet_moving_variance)
-                else:
-                    not_found_param.append(darknet_moving_variance)
-                if darknet_gamma in param_dict:
-                    cell.gamma.set_data(param_dict[darknet_gamma].data)
-                    find_param.append(darknet_gamma)
-                else:
-                    not_found_param.append(darknet_gamma)
-                if darknet_beta in param_dict:
-                    cell.beta.set_data(param_dict[darknet_beta].data)
-                    find_param.append(darknet_beta)
-                else:
-                    not_found_param.append(darknet_beta)
-
-    args.logger.info('================found_param {}========='.format(len(find_param)))
-    args.logger.info(find_param)
-    args.logger.info('================not_found_param {}========='.format(len(not_found_param)))
-    args.logger.info(not_found_param)
-    args.logger.info('=====load {} successfully ====='.format(ckpt_path))
+    load_param_into_net(net, param_dict)
+
+    param_not_load = []
+    for _, param in net.parameters_and_names():
+        if param.name in param_dict:
+            pass
+        else:
+            param_not_load.append(param.name)
+    print("not loading param is :", len(param_not_load))
+    for param_name in param_not_load:
+        print("param_name not load:", param_name)
 
     return net
 

model_zoo/official/cv/yolov3_darknet53/train.py

@@ -218,7 +218,7 @@ def train():
                                           level="O2", keep_batchnorm_fp32=False)
         keep_loss_fp32(network)
     else:
-        network = TrainingWrapper(network, opt)
+        network = TrainingWrapper(network, opt, sens=args.loss_scale)
         network.set_train()
 
     if args.rank_save_ckpt_flag: