!14920 clean redundant code

From: @zhao_ting_v
Reviewed-by: @oacjiewen,@wuxuejian
Signed-off-by: @wuxuejian

mindspore/ccsrc/backend/kernel_compiler/cpu/pad_cpu_kernel.cc

@@ -83,7 +83,6 @@ void PadCPUKernel::LaunchKernel(const std::vector<AddressPtr> &inputs, const std
   const int pad_channel_after = paddings_[1][1];
   const T pad_value = T(0);
 
-  // const int num = input_shape_[0];
   const int channels_orig = input_shape_[1];
   const int old_height = input_shape_[2];
   const int old_width = input_shape_[3];

model_zoo/official/cv/centerface/dependency/centernet/src/lib/detectors/base_detector.py

@@ -122,7 +122,6 @@ class CenterFaceDetector():
             meta['out_height'], meta['out_width'])
         for j in range(1, self.num_classes + 1):
             dets[0][j] = np.array(dets[0][j], dtype=np.float32).reshape(-1, 15)
-            # import pdb; pdb.set_trace()
             dets[0][j][:, :4] /= scale
             dets[0][j][:, 5:] /= scale
         return dets[0]
@@ -157,7 +156,6 @@ class CenterFaceDetector():
             if not pre_processed:
                 images, meta = self.pre_process(image, scale, meta) # --1: pre_process
             else:
-                # import pdb; pdb.set_trace()
                 images = pre_processed_images['images'][scale][0]
                 meta = pre_processed_images['meta'][scale]
                 meta = {k: v.numpy()[0] for k, v in meta.items()}

model_zoo/official/cv/centerface/dependency/evaluate/eval.py

@@ -116,10 +116,8 @@ def get_preds(pred_dir):
     """Get preds"""
     events = os.listdir(pred_dir)
     boxes = dict()
-    #pbar = tqdm.tqdm(events)
     pbar = events
     for event in pbar:
-        #pbar.set_description('Reading Predictions ')
         event_dir = os.path.join(pred_dir, event)
         event_images = os.listdir(event_dir)
         current_event = dict()
@@ -258,7 +256,6 @@ def evaluation(pred_evaluation, gt_path, iou_thresh=0.4):
         count_face = 0
         pr_curve = np.zeros((thresh_num, 2)).astype('float')
         # [hard, medium, easy]
-        # pbar = tqdm.tqdm(range(event_num))  #  61
         pbar = range(event_num)
         error_count = 0
         for i in pbar:

model_zoo/official/cv/centerface/src/centerface.py

@@ -171,7 +171,6 @@ class CenterFaceLoss(nn.Cell):
         self.reg_loss = SmoothL1LossNew()
         self.reg_loss_cmask = SmoothL1LossNewCMask()
         self.print = P.Print()
-        # self.reduce_sum = P.ReduceSum()
 
     def construct(self, output_hm, output_wh, output_off, output_kps, hm, reg_mask, ind, wh, wight_mask, hm_offset,
                   hps_mask, landmarks):
@@ -190,7 +189,6 @@ class CenterFaceLoss(nn.Cell):
         F.depend(loss, F.sqrt(F.cast(wight_mask, mstype.float32)))
         F.depend(loss, F.sqrt(F.cast(reg_mask, mstype.float32)))
         # add print when you want to see loss detail and do debug
-        #self.print('hm_loss=', hm_loss, 'wh_loss=', wh_loss, 'off_loss=', off_loss, 'lm_loss=', lm_loss, 'loss=', loss)
         return loss
 
 

model_zoo/official/cv/centerface/src/losses.py

@@ -69,11 +69,9 @@ class SmoothL1LossNew(nn.Cell):
         :return:
         '''
         output = self.transpose(output, (0, 2, 3, 1))
-        # dim = self.shape(output)[3]
         mask = P.Select()(P.Equal()(ind, 1), P.Fill()(mstype.float32, P.Shape()(ind), 1.0), P.Fill()(mstype.float32,
                                                                                                      P.Shape()(ind),
                                                                                                      0.0))
-        # ind = self.cast(ind, mstype.float32)
         target = self.cast(target, mstype.float32)
         output = self.cast(output, mstype.float32)
         num = self.cast(self.sum(mask, ()), mstype.float32)

model_zoo/official/cv/centerface/src/utils.py

@@ -109,15 +109,12 @@ def get_param_groups(network):
         parameter_name = x.name
         if parameter_name.endswith('.bias'):
             # all bias not using weight decay
-            # print('no decay:{}'.format(parameter_name))
             no_decay_params.append(x)
         elif parameter_name.endswith('.gamma'):
             # bn weight bias not using weight decay, be carefully for now x not include BN
-            # print('no decay:{}'.format(parameter_name))
             no_decay_params.append(x)
         elif parameter_name.endswith('.beta'):
             # bn weight bias not using weight decay, be carefully for now x not include BN
-            # print('no decay:{}'.format(parameter_name))
             no_decay_params.append(x)
         else:
             decay_params.append(x)
@@ -224,7 +221,6 @@ class LOGGER(logging.Logger):
         self.info('Args:')
         args_dict = vars(args)
         for key in args_dict.keys():
-            # self.info('--> {}: {}'.format(key, args_dict[key]))
             self.info('--> %s', key)
         self.info('')
 

model_zoo/official/cv/centerface/train.py

@@ -159,7 +159,6 @@ if __name__ == "__main__":
         parallel_mode = ParallelMode.STAND_ALONE
         degree = 1
 
-    # context.set_auto_parallel_context(parallel_mode=parallel_mode, device_num=degree, parameter_broadcast=True, gradients_mean=True)
     # Notice: parameter_broadcast should be supported, but current version has bugs, thus been disabled.
     # To make sure the init weight on all npu is the same, we need to set a static seed in default_recurisive_init when weight initialization
     context.set_auto_parallel_context(parallel_mode=parallel_mode, gradients_mean=True, device_num=degree)

model_zoo/official/cv/ctpn/postprocess.py

@@ -51,8 +51,6 @@ def get_gt_box(img_file, label_path):
         label_info = line.split(",")
         print(label_info)
         gt_boxs.append([int(label_info[0]), int(label_info[1]), int(label_info[2]), int(label_info[3])])
-        #print(line)
-        #print(gt_boxs)
 
     return gt_boxs
 def ctpn_infer_test(dataset_path='', result_path='', label_path=''):

model_zoo/official/cv/deeptext/src/Deeptext/bbox_assign_sample_stage2.py

@@ -219,8 +219,6 @@ class BboxAssignSampleForRcnn(nn.Cell):
         else:
             valid_neg_index = self.logicaland(self.concat((self.check_neg_mask, unvalid_pos_index)), valid_neg_index)
         valid_neg_index = self.logicaland(valid_neg_index, self.check_neg_mask_ignore_end)
-        # import pdb
-        # pdb.set_trace()
         neg_index = self.reshape(neg_index, self.reshape_shape_neg)
 
         valid_neg_index = self.cast(valid_neg_index, mstype.int32)

model_zoo/official/cv/deeptext/src/Deeptext/deeptext_vgg16.py

@@ -42,7 +42,6 @@ def _conv(in_channels, out_channels, kernel_size=3, stride=1, padding=0, pad_mod
     layers += [nn.Conv2d(in_channels, out_channels,
                          kernel_size=kernel_size, stride=stride, padding=padding,
                          pad_mode=pad_mode, weight_init=weights, has_bias=True, bias_init=bias_conv)]
-    # layers += [nn.BatchNorm2d(out_channels)]
     return nn.SequentialCell(layers)
 
 
@@ -195,7 +194,6 @@ class Deeptext_VGG16(nn.Cell):
         self.vgg16_feature_extractor = VGG16FeatureExtraction()
 
     def construct(self, img_data, img_metas, gt_bboxes, gt_labels, gt_valids):
-        # f1, f2, f3, f4, f5 = self.vgg16_feature_extractor(img_data)
         _, _, _, f4, f5 = self.vgg16_feature_extractor(img_data)
         f4 = self.cast(f4, mstype.float32)
         f5 = self.cast(f5, mstype.float32)
@@ -306,15 +304,11 @@ class Deeptext_VGG16(nn.Cell):
             out_boxes_i = self.decode(rois, reg_logits_i)
             boxes_all += (out_boxes_i,)
 
-        # img_metas_all = self.split(img_metas)
         scores_all = self.split(scores)
         mask_all = self.split(self.cast(mask_logits, mstype.int32))
 
         boxes_all_with_batchsize = ()
         for i in range(self.test_batch_size):
-            # scale = self.split_shape(self.squeeze(img_metas_all[i]))
-            # scale_h = scale[2]
-            # scale_w = scale[3]
             boxes_tuple = ()
             for j in range(self.num_classes):
                 boxes_tmp = self.split(boxes_all[j])

model_zoo/official/cv/deeptext/src/Deeptext/vgg16.py

@@ -21,7 +21,6 @@ from mindspore.ops import operations as P
 
 def _conv(in_channels, out_channels, kernel_size=3, stride=1, padding=0, pad_mode='pad'):
     """Conv2D wrapper."""
-    # shape = (out_channels, in_channels, kernel_size, kernel_size)
     weights = 'ones'
     layers = []
     layers += [nn.Conv2d(in_channels, out_channels,

model_zoo/official/cv/deeptext/src/dataset.py

@@ -404,7 +404,6 @@ def create_label(is_training):
             image_path = os.path.join(coco_root, data_type, file_name)
             annos = []
             for label in anno:
-                # if label["utf8_string"] != '':
                 bbox = label["bbox"]
                 x1, x2 = bbox[0], bbox[0] + bbox[2]
                 y1, y2 = bbox[1], bbox[1] + bbox[3]

model_zoo/official/cv/nasnet/train.py

@@ -104,10 +104,6 @@ if __name__ == '__main__':
     optimizer = RMSProp(group_params, lr, decay=cfg.rmsprop_decay, weight_decay=cfg.weight_decay,
                         momentum=cfg.momentum, epsilon=cfg.opt_eps, loss_scale=cfg.loss_scale)
 
-    # net_with_grads = NASNetAMobileTrainOneStepWithClipGradient(net_with_loss, optimizer)
-    # net_with_grads.set_train()
-    # model = Model(net_with_grads)
-
     # high performance
     net_with_loss.set_train()
     model = Model(net_with_loss, optimizer=optimizer)

model_zoo/official/cv/openpose/eval.py

@@ -91,8 +91,7 @@ def load_model(test_net, model_path):
             continue
         elif key.startswith('network'):
             param_dict_new[key[8:]] = values
-        # else:
-        # param_dict_new[key] = values
+
     load_param_into_net(test_net, param_dict_new)
 
 def preprocess(img):
@@ -310,11 +309,8 @@ def detect(img, network):
     orig_img_h, orig_img_w, _ = orig_img.shape
 
     input_w, input_h = compute_optimal_size(orig_img, params['inference_img_size']) # 368
-    # map_w, map_h = compute_optimal_size(orig_img, params['heatmap_size']) # 320
     map_w, map_h = compute_optimal_size(orig_img, params['inference_img_size'])
 
-    # print("image size is: ", input_w, input_h)
-
     resized_image = cv2.resize(orig_img, (input_w, input_h))
     x_data = preprocess(resized_image)
     x_data = Tensor(x_data, mstype.float32)
@@ -388,7 +384,6 @@ def draw_person_pose(orig_img, poses):
     return canvas
 
 def depreprocess(img):
-    #x_data = img.astype('f')
     x_data = img[0]
     x_data += 0.5
     x_data *= 255
@@ -420,7 +415,6 @@ def val():
         poses, scores = detect(img, network)
 
         if poses.shape[0] > 0:
-            #print("got poses")
             for index, pose in enumerate(poses):
                 data = dict()
 
@@ -437,7 +431,6 @@ def val():
             print("Predict poses size is zero.", flush=True)
         img = draw_person_pose(cv2.cvtColor(img, cv2.COLOR_BGR2RGB), poses)
 
-        #print('Saving result into',str(img_id)+'.png...')
         save_path = os.path.join(args.output_path, str(img_id)+".png")
         cv2.imwrite(save_path, img)
 

model_zoo/official/cv/openpose/src/dataset.py

@@ -69,7 +69,6 @@ class txtdataset():
                 if person_cnt > 0:
                     annotations = valid_annotations_for_img
             if annotations is None:
-                #print(img_id,'is removed')
                 self.imgIds.remove(img_id)
 
     def overlay_paf(self, img, paf):
@@ -137,7 +136,6 @@ class txtdataset():
         max_scale = min(max(max_scale, 1), params['max_scale'])
 
         scale = float((max_scale - min_scale) * random.random() + min_scale)
-        #scale = random.random()*1.5+0.5
         shape = (round(w * scale), round(h * scale))
 
         resized_img, resized_mask, resized_poses = self.resize_data(img, ignore_mask, poses, shape)
@@ -145,7 +143,6 @@ class txtdataset():
 
     def random_rotate_img(self, img, mask, poses):
         h, w, _ = img.shape
-        # degree = (random.random() - 0.5) * 2 * params['max_rotate_degree']
         degree = np.random.randn() / 3 * params['max_rotate_degree']
         rad = degree * math.pi / 180
         center = (w / 2, h / 2)
@@ -473,12 +470,8 @@ class txtdataset():
         resized_img, ignore_mask, resized_poses = self.resize_data(img, ignore_mask, poses,
                                                                    shape=(self.insize, self.insize))
 
-        # heatmaps = self.generate_heatmaps(resized_img, resized_poses, params['heatmap_sigma'])
-        # resized_heatmaps = self.resize_output(heatmaps)
         resized_heatmaps = self.generate_heatmaps_fast(resized_img, resized_poses, params['heatmap_sigma'])
 
-        # pafs = self.generate_pafs(resized_img, resized_poses, params['paf_sigma'])
-        # resized_pafs = self.resize_output(pafs)
         resized_pafs = self.generate_pafs_fast(resized_img, resized_poses, params['paf_sigma'])
 
         ignore_mask = cv2.morphologyEx(ignore_mask.astype('uint8'), cv2.MORPH_DILATE, np.ones((16, 16))).astype('bool')

model_zoo/official/cv/openpose/src/loss.py

@@ -74,8 +74,6 @@ class openpose_loss(_Loss):
         self.maxoftensor = P.ArgMaxWithValue(-1)
 
     def mean_square_error(self, map1, map2, mask=None):
-        # print("mask", mask)
-        # import pdb; pdb.set_trace()
         if mask is None:
             mse = self.reduceMean((map1 - map2) ** 2)
             return mse
@@ -98,14 +96,6 @@ class openpose_loss(_Loss):
         paf_masks = F.stop_gradient(paf_masks)
         heatmap_masks = F.stop_gradient(heatmap_masks)
         for logit_paf_t, logit_heatmap_t in zip(logit_paf, logit_heatmap):
-            # TEST
-            # tensor1 -- tuple
-            # tensor1 = self.maxoftensor(logit_paf_t)[1]
-            # tensor2 = self.maxoftensor(logit_heatmap_t)[1]
-            # tensor3 = self.maxoftensor(tensor1)[1]
-            # tensor4 = self.maxoftensor(tensor2)[1]
-            # self.print("paf",tensor3)
-            # self.print("heatmaps",tensor2)
             pafs_loss_t = self.mean_square_error(logit_paf_t, gt_paf, paf_masks)
             heatmaps_loss_t = self.mean_square_error(logit_heatmap_t, gt_heatmap, heatmap_masks)
 
@@ -125,8 +115,6 @@ class BuildTrainNetwork(nn.Cell):
         logit_pafs, logit_heatmap = self.network(input_data)
         loss, _, _ = self.criterion(logit_pafs, logit_heatmap, gt_paf, gt_heatmap, mask)
         return loss
-        #loss = self.criterion(logit_pafs, logit_heatmap, gt_paf, gt_heatmap, mask)
-        # return loss, heatmaps_loss, pafs_loss
 
 class TrainOneStepWithClipGradientCell(nn.Cell):
     '''TrainOneStepWithClipGradientCell'''

model_zoo/official/cv/openpose/src/openposenet.py

@@ -88,14 +88,12 @@ class Vgg(nn.Cell):
         in_channels = 3
         for v in cfg:
             if v == 'M':
-                # layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
                 layers += [nn.MaxPool2d(kernel_size=2, stride=2, pad_mode='same')]
             else:
                 conv2d = Conv2d(in_channels=in_channels,
                                 out_channels=v,
                                 kernel_size=3,
                                 stride=1,
-                                # padding=1,
                                 pad_mode='same',
                                 has_bias=True)
                 if batch_norm:

model_zoo/official/cv/openpose/src/utils.py

@@ -108,17 +108,13 @@ def get_lr(lr, lr_gamma, steps_per_epoch, max_epoch_train, lr_steps, group_size,
 def load_model(test_net, model_path):
     if model_path:
         param_dict = load_checkpoint(model_path)
-        # print(type(param_dict))
         param_dict_new = {}
         for key, values in param_dict.items():
-            # print('key:', key)
             if key.startswith('moment'):
                 continue
             elif key.startswith('network.'):
                 param_dict_new[key[8:]] = values
 
-            # else:
-            # param_dict_new[key] = values
         load_param_into_net(test_net, param_dict_new)
 
 

model_zoo/official/cv/resnet152/src/lr_generator.py

@@ -144,7 +144,6 @@ def get_lr(lr_init, lr_end, lr_max, warmup_epochs, total_epochs, steps_per_epoch
     """
     lr_each_step = []
     total_steps = int(steps_per_epoch * total_epochs)
-    # warmup_steps = steps_per_epoch * warmup_epochs
     warmup_steps = warmup_epochs
 
     if lr_decay_mode == 'steps':

model_zoo/official/cv/retinaface_resnet50/eval.py

@@ -406,14 +406,6 @@ def val():
         predict_result_path = detection.write_result()
         print('predict result path is {}'.format(predict_result_path))
 
-
-    # # TEST
-    # import json
-    # with open('./widerface_result/predict_2020_09_08_11_07_25.json', 'r') as f:
-    #     result = json.load(f)
-    # detection.results = result
-
-
     detection.get_eval_result()
     print('Eval done.')
 

model_zoo/official/cv/simple_pose/eval.py

@@ -112,7 +112,6 @@ def validate(cfg, val_dataset, model, output_dir):
             if cfg.TEST.SHIFT_HEATMAP:
                 output_flipped[:, :, :, 1:] = \
                     output_flipped.copy()[:, :, :, 0:-1]
-                # output_flipped[:, :, :, 0] = 0
 
             output = (output + output_flipped) * 0.5
 

model_zoo/official/cv/unet/src/utils.py

@@ -58,7 +58,7 @@ def apply_eval(eval_param_dict):
     dataset = eval_param_dict["dataset"]
     metrics_name = eval_param_dict["metrics_name"]
     index = 0 if metrics_name == "dice_coeff" else 1
-    eval_score = model.eval(dataset, dataset_sink_mode=False)[metrics_name][index]
+    eval_score = model.eval(dataset, dataset_sink_mode=False)["dice_coeff"][index]
     return eval_score
 
 class dice_coeff(nn.Metric):

model_zoo/official/cv/yolov4/src/transforms.py

@@ -146,7 +146,6 @@ def _preprocess_true_boxes(true_boxes, anchors, in_shape, num_classes, max_boxes
     num_layers = anchors.shape[0] // 3
     anchor_mask = [[6, 7, 8], [3, 4, 5], [0, 1, 2]]
     true_boxes = np.array(true_boxes, dtype='float32')
-    # input_shape = np.array([in_shape, in_shape], dtype='int32')
     input_shape = np.array(in_shape, dtype='int32')
     boxes_xy = (true_boxes[..., 0:2] + true_boxes[..., 2:4]) // 2.
     # trans to box center point
@@ -208,8 +207,6 @@ def _preprocess_true_boxes(true_boxes, anchors, in_shape, num_classes, max_boxes
                         y_true[l][j, i, k, 5 + c] = 1.
 
         threshold_anchor = (iou > iou_threshold)
-        # print('threshold_anchor\n', threshold_anchor.shape, threshold_anchor)
-        # for t, n in enumerate(best_anchor):
         for t in range(threshold_anchor.shape[0]):
             for n in range(threshold_anchor.shape[1]):
                 if not threshold_anchor[t][n]:

model_zoo/official/cv/yolov4/test.py

@@ -292,7 +292,6 @@ def test():
         exit(1)
 
     data_root = args.data_root
-    # annFile = args.annFile
 
     config = ConfigYOLOV4CspDarkNet53()
     if args.testing_shape:

model_zoo/official/nlp/gnmt_v2/src/gnmt_model/beam_search.py

@@ -91,7 +91,6 @@ class TileBeam(nn.Cell):
         # add an dim
         input_tensor = self.expand(input_tensor, 1)
         # get tile shape: [1, beam, ...]
-        # shape = self.shape(input_tensor)
         tile_shape = (1,) + (self.beam_width,)
         for _ in range(len(shape) - 1):
             tile_shape = tile_shape + (1,)
@@ -420,7 +419,6 @@ class BeamSearchDecoder(nn.Cell):
 
         # add length penalty scores
         penalty_len = self.length_penalty(state_length)
-        # return penalty_len
         log_probs = self.real_div(state_log_probs, penalty_len)
         penalty_cov = C.clip_by_value(accu_attn_scores, 0.0, 1.0)
         penalty_cov = self.log(penalty_cov)

model_zoo/official/nlp/gnmt_v2/src/gnmt_model/decoder_beam_infer.py

@@ -50,7 +50,6 @@ class PredLogProbs(nn.Cell):
         self.compute_type = compute_type
         self.dtype = dtype
         self.log_softmax = nn.LogSoftmax(axis=-1)
-        # self.shape_flat_sequence_tensor = (self.batch_size * self.seq_length, self.width)
         self.cast = P.Cast()
 
     def construct(self, logits):

model_zoo/official/nlp/gnmt_v2/src/utils/initializer.py

@@ -56,10 +56,6 @@ def weight_variable(shape):
     Returns:
         Tensor, var.
     """
-    # scale_shape = shape
-    # fan_in, fan_out = _compute_fans(scale_shape)
-    # scale = 1.0 / max(1., (fan_in + fan_out) / 2.)
-    # limit = math.sqrt(3.0 * scale)
     limit = 0.1
     values = np.random.uniform(-limit, limit, shape)
     return values

model_zoo/official/nlp/gnmt_v2/src/utils/optimizer.py

@@ -210,7 +210,6 @@ class Adam(Optimizer):
         validator.check_value_type("use_locking", use_locking, [bool], self.cls_name)
         validator.check_value_type("use_nesterov", use_nesterov, [bool], self.cls_name)
         validator.check_value_type("loss_scale", loss_scale, [float], self.cls_name)
-        # validator.check_number_range("loss_scale", loss_scale, 1.0, float("inf"), Rel.INC_LEFT, self.cls_name)
 
         self.beta1 = Tensor(beta1, mstype.float32)
         self.beta2 = Tensor(beta2, mstype.float32)

model_zoo/official/nlp/gnmt_v2/train.py

@@ -123,7 +123,6 @@ def _load_checkpoint_to_net(config, network):
                 if name.endswith(".gamma"):
                     param.set_data(one_weight(value.asnumpy().shape))
                 elif name.endswith(".beta") or name.endswith(".bias"):
-                    # param.set_data(zero_weight(value.asnumpy().shape))
                     if param.data.dtype == "Float32":
                         param.set_data((weight_variable(value.asnumpy().shape).astype(np.float32)))
                     elif param.data.dtype == "Float16":

model_zoo/official/recommend/naml/postprocess.py

@@ -64,7 +64,6 @@ class NAMLMetric:
     def update(self, predict, y_true):
         predict = predict.flatten()
         y_true = y_true.flatten()
-        # predict = np.interp(predict, (predict.min(), predict.max()), (0, 1))
         self.AUC_list.append(AUC(y_true, predict))
         self.MRR_list.append(MRR(y_true, predict))
         self.nDCG5_list.append(nDCG(y_true, predict, 5))

model_zoo/official/recommend/naml/src/utils.py

@@ -117,7 +117,6 @@ class NAMLMetric:
     def update(self, predict, y_true):
         predict = predict.flatten()
         y_true = y_true.flatten()
-        # predict = np.interp(predict, (predict.min(), predict.max()), (0, 1))
         self.AUC_list.append(AUC(y_true, predict))
         self.MRR_list.append(MRR(y_true, predict))
         self.nDCG5_list.append(nDCG(y_true, predict, 5))

model_zoo/official/recommend/ncf/eval.py

@@ -65,7 +65,6 @@ def test_eval():
 
     loss_net = NetWithLossClass(ncf_net)
     train_net = TrainStepWrap(loss_net)
-    # train_net.set_train()
     eval_net = PredictWithSigmoid(ncf_net, topk, num_eval_neg)
 
     ncf_metric = NCFMetric()

model_zoo/official/recommend/ncf/src/dataset.py

@@ -529,8 +529,6 @@ class DistributedSamplerOfEval:
         self._eval_batch_size = eval_batch_size
 
         self._batchs_per_rank = int(math.ceil(self._eval_batches_per_epoch / rank_size))
-        # self._samples_per_rank = int(math.ceil(self._batchs_per_rank *  self._eval_batch_size))
-        # self._total_num_samples = self._samples_per_rank * self._rank_size
 
     def __iter__(self):
         indices = [(x * self._eval_users_per_batch, (x + self._rank_id + 1) * self._eval_users_per_batch)

model_zoo/official/recommend/ncf/src/ncf.py

@@ -201,7 +201,6 @@ class NetWithLossClass(nn.Cell):
     """
     def __init__(self, network):
         super(NetWithLossClass, self).__init__(auto_prefix=False)
-        #self.loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True)
         self.loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True)
         self.network = network
         self.reducesum = P.ReduceSum(keep_dims=False)

model_zoo/research/audio/wavenet/wavenet_vocoder/upsample.py

@@ -58,15 +58,11 @@ class UpsampleNetwork(nn.Cell):
         for scale in upsample_scales:
             freq_axis_padding = (freq_axis_kernel_size - 1) // 2
             k_size = (freq_axis_kernel_size, scale * 2 + 1)
-            # padding = (freq_axis_padding, scale)
             padding = (freq_axis_padding, freq_axis_padding, scale, scale)
             stretch = Resize(scale, 1, mode)
             conv = nn.Conv2d(1, 1, kernel_size=k_size, has_bias=False, pad_mode='pad', padding=padding)
             up_layers.append(stretch)
             up_layers.append(conv)
-            # if upsample_activation != "none":
-            #     nonlinear = _get_activation(upsample_activation)
-            #     up_layers.append(nonlinear(**upsample_activation_params))
         self.up_layers = nn.CellList(up_layers)
 
     def construct(self, c):
@@ -86,8 +82,6 @@ class UpsampleNetwork(nn.Cell):
         # B x C x T
         c = self.squeeze_op(c)
 
-        # if self.indent > 0:
-        #     c = c[:, :, self.indent:-self.indent]
         return c
 
 

model_zoo/research/cv/IPT/src/data/common.py

@@ -67,9 +67,6 @@ def np2Tensor(*args, rgb_range=255):
         np_transpose = np.ascontiguousarray(img.transpose((2, 0, 1)))
         tensor = np_transpose.astype(np.float32)
         tensor = tensor * (rgb_range / 255)
-        # tensor = torch.from_numpy(np_transpose).float()
-        # tensor.mul_(rgb_range / 255)
-
         return tensor
 
     return [_np2Tensor(a) for a in args]

model_zoo/research/cv/MaskedFaceRecognition/dataset/Dataset.py

@@ -159,7 +159,6 @@ class ImageFolderPKDataset:
         for idx, sample in enumerate(self.samples):
             label = sample[1]
             id2range[label].append((sample, idx))
-        # print(id2range)
         for key in id2range:
             id2range[key].sort(key=lambda x: int(os.path.basename(x[0][0]).split(".")[0]))
             for item in id2range[key]:

model_zoo/research/cv/MaskedFaceRecognition/train.py

@@ -93,9 +93,7 @@ if __name__ == '__main__':
 
     model = Model(train_net, eval_network=test_net, metrics={"Accuracy": Accuracy()})
 
-    # time_cb = TimeMonitor(data_size=step_size)
     loss_cb = LossMonitor()
-    #cb = [time_cb, loss_cb]
     cb = [loss_cb]
     config_ck = CheckpointConfig(save_checkpoint_steps=config.save_checkpoint_steps, \
         keep_checkpoint_max=config.keep_checkpoint_max)

model_zoo/research/cv/MaskedFaceRecognition/utils/metric.py

@@ -54,12 +54,10 @@ def cmc(
     assert isinstance(gallery_ids, np.ndarray)
     # assert isinstance(query_cams, np.ndarray)
     # assert isinstance(gallery_cams, np.ndarray)
-    # separate_camera_set=False
     first_match_break = True
     m, _ = distmat.shape
     # Sort and find correct matches
     indices = np.argsort(distmat, axis=1)
-    #print(indices)
     matches = (gallery_ids[indices] == query_ids[:, np.newaxis])
     # Compute CMC for each query
     ret = np.zeros([m, topk])
@@ -174,21 +172,13 @@ def mean_ap(
     is_valid_query = np.zeros(m)
     for i in range(m):
         # Filter out the same id and same camera
-        # valid = ((gallery_ids[indices[i]] != query_ids[i]) |
-        #         (gallery_cams[indices[i]] != query_cams[i]))
         valid = (gallery_ids[indices[i]] != query_ids[i]) | (gallery_ids[indices[i]] == query_ids[i])
-        # valid = indices[i] != i
-        # valid = (gallery_cams[indices[i]] != query_cams[i])
         y_true = matches[i, valid]
         y_score = -distmat[i][indices[i]][valid]
 
-        # y_true=y_true[0:100]
-        # y_score=y_score[0:100]
         if not np.any(y_true): continue
         is_valid_query[i] = 1
         aps[i] = average_precision_score(y_true, y_score)
-    # if not aps:
-    #     raise RuntimeError("No valid query")
     if average:
         return float(np.sum(aps)) / np.sum(is_valid_query)
     return aps, is_valid_query

model_zoo/research/hpc/sponge/src/angle.py

@@ -34,7 +34,6 @@ class Angle:
                     self.angle_with_H_numbers = value[4]
                     self.angle_without_H_numbers = value[5]
                     self.angle_numbers = self.angle_with_H_numbers + self.angle_without_H_numbers
-                    # print(self.angle_numbers)
                     information = []
                     information.extend(value)
                     while count < 15:
@@ -108,7 +107,6 @@ class Angle:
                     if "%FORMAT" in context[start_idx]:
                         continue
                     else:
-                        # print(start_idx)
                         value = list(map(float, context[start_idx].strip().split()))
                         information.extend(value)
                         count += len(value)

model_zoo/research/hpc/sponge/src/md_information.py

@@ -154,7 +154,6 @@ class md_information:
             self.simulation_start_time = float(context[1].strip().split()[1])
             while count <= 6 * self.atom_numbers + 3:
                 start_idx += 1
-                # print(start_idx)
                 value = list(map(float, context[start_idx].strip().split()))
                 information.extend(value)
                 count += len(value)

model_zoo/research/nlp/dscnn/src/dataset.py

@@ -32,7 +32,6 @@ class NpyDataset():
     def __getitem__(self, item):
         data = self.data[item]
         label = self.label[item]
-        # return data, label
         return data.astype(np.float32), label.astype(np.int32)
 
 

model_zoo/research/nlp/dscnn/src/download_process_data.py

@@ -195,7 +195,6 @@ class AudioProcessor():
         sliced_foreground = padded_foreground[time_shift_offset: time_shift_offset + desired_samples]
         background_add = background_data[0] * background_volume + sliced_foreground
         background_clamp = np.clip(background_add, -1.0, 1.0)
-        # feature = mfcc(background_clamp, samplerate=FLAGS.sample_rate, winlen=0.03, winstep=0.01, numcep=40, nfilt=40).flatten()
         feature = mfcc(background_clamp, samplerate=FLAGS.sample_rate, winlen=FLAGS.window_size_ms / 1000,
                        winstep=FLAGS.window_stride_ms / 1000,
                        numcep=FLAGS.dct_coefficient_count, nfilt=40, nfft=1024, lowfreq=20, highfreq=7000).flatten()

model_zoo/research/nlp/tprr/src/rerank_and_reader_utils.py

@@ -382,7 +382,6 @@ def get_ans_from_pos(tokenizer, examples, features, y1, y2, unique_id):
         tok_text = " ".join(tok_text.split())
         orig_text = " ".join(orig_tokens)
         final_text = get_final_text(tok_text, orig_text, True, False)
-    # print("final_text: " + final_text)
     return final_text
 
 

model_zoo/research/recommend/autodis/train.py

@@ -23,7 +23,6 @@ from mindspore.communication.management import init, get_rank
 from mindspore.train.model import Model
 from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, TimeMonitor
 from mindspore.common import set_seed
-#from mindspore.profiler import Profiler
 
 from src.autodis import ModelBuilder, AUCMetric
 from src.config import DataConfig, ModelConfig, TrainConfig
@@ -75,7 +74,6 @@ if __name__ == '__main__':
         rank_id = None
 
     # Init Profiler
-    #profiler = Profiler(output_path='./data', is_detail=True, is_show_op_path=False, subgraph='all')
 
     ds_train = create_dataset(args_opt.dataset_path,
                               train_mode=True,