replace deprecated numpy dtypes

eaidova · eaidova · commit 3422a529352f · 2022-12-20T02:01:21.000-05:00
diff --git a/demos/3d_segmentation_demo/python/3d_segmentation_demo.py b/demos/3d_segmentation_demo/python/3d_segmentation_demo.py
@@ -214,7 +214,7 @@ def read_image(test_data_path, data_name, sizes=(128, 128, 128), is_series=True,
 
     bbox_min = np.min(bboxes[:, 0, :], axis=0).ravel().astype(int)
     bbox_max = np.max(bboxes[:, 1, :], axis=0).ravel().astype(int)
-    bbox = np.zeros(shape=(2, 3), dtype=np.float)
+    bbox = np.zeros(shape=(2, 3), dtype=float)
     bbox[0] = bbox_min
     bbox[1] = bbox_max
 
diff --git a/demos/common/python/openvino/model_zoo/model_api/models/centernet.py b/demos/common/python/openvino/model_zoo/model_api/models/centernet.py
@@ -132,8 +132,8 @@ def _topk(scores, K=40):
         topk_inds = np.argpartition(scores, -K, axis=1)[:, -K:]
         topk_scores = scores[np.arange(scores.shape[0])[:, None], topk_inds]
 
-        topk_ys = (topk_inds / width).astype(np.int32).astype(np.float)
-        topk_xs = (topk_inds % width).astype(np.int32).astype(np.float)
+        topk_ys = (topk_inds / width).astype(np.int32).astype(float)
+        topk_xs = (topk_inds % width).astype(np.int32).astype(float)
 
         topk_scores = topk_scores.reshape((-1))
         topk_ind = np.argpartition(topk_scores, -K)[-K:]
diff --git a/demos/common/python/openvino/model_zoo/model_api/models/ctpn.py b/demos/common/python/openvino/model_zoo/model_api/models/ctpn.py
@@ -326,7 +326,7 @@ def build_graph(self, text_proposals, scores, im_size):
             boxes_table[int(box[0])].append(index)
         self.boxes_table = boxes_table
 
-        graph = np.zeros((text_proposals.shape[0], text_proposals.shape[0]), np.bool)
+        graph = np.zeros((text_proposals.shape[0], text_proposals.shape[0]), bool)
 
         for index, box in enumerate(text_proposals):
             successions = self.get_successions(index)
@@ -379,7 +379,7 @@ def fit_y(x, y, x1, x2):
         text_lines[:, :4].clip(min=0, max=(image_size[1] - 1, image_size[0] - 1, image_size[1] - 1, image_size[0] - 1),
                                out=text_lines[:, :4])
 
-        text_recs = np.zeros((len(text_lines), 9), np.float)
+        text_recs = np.zeros((len(text_lines), 9), float)
         for index, line in enumerate(text_lines):
             xmin, ymin, xmax, ymax = line[0], line[1], line[2], line[3]
             text_recs[index, 0], text_recs[index, 1], text_recs[index, 2], text_recs[index, 3] = xmin, ymin, xmax, ymin
diff --git a/demos/common/python/openvino/model_zoo/model_api/models/retinaface.py b/demos/common/python/openvino/model_zoo/model_api/models/retinaface.py
@@ -265,7 +265,7 @@ def bbox_pred(boxes, box_deltas):
         if boxes.shape[0] == 0:
             return np.zeros((0, box_deltas.shape[1]))
 
-        boxes = boxes.astype(np.float, copy=False)
+        boxes = boxes.astype(float, copy=False)
         widths = boxes[:, 2] - boxes[:, 0] + 1.0
         heights = boxes[:, 3] - boxes[:, 1] + 1.0
         ctr_x = boxes[:, 0] + 0.5 * (widths - 1.0)
@@ -309,7 +309,7 @@ def anchors_plane(height, width, stride, base_anchors):
     def landmark_pred(boxes, landmark_deltas):
         if boxes.shape[0] == 0:
             return np.zeros((0, landmark_deltas.shape[1]))
-        boxes = boxes.astype(np.float, copy=False)
+        boxes = boxes.astype(float, copy=False)
         widths = boxes[:, 2] - boxes[:, 0] + 1.0
         heights = boxes[:, 3] - boxes[:, 1] + 1.0
         ctr_x = boxes[:, 0] + 0.5 * (widths - 1.0)
diff --git a/demos/face_recognition_demo/python/face_identifier.py b/demos/face_recognition_demo/python/face_identifier.py
@@ -136,7 +136,7 @@ def _align_rois(self, face_images, face_landmarks):
 
         for image, image_landmarks in zip(face_images, face_landmarks):
             scale = np.array((image.shape[1], image.shape[0]))
-            desired_landmarks = np.array(self.REFERENCE_LANDMARKS, dtype=np.float64) * scale
+            desired_landmarks = np.array(self.REFERENCE_LANDMARKS, dtype=float) * scale
             landmarks = image_landmarks * scale
 
             transform = FaceIdentifier.get_transform(desired_landmarks, landmarks)
diff --git a/demos/smart_classroom_demo/utils/action_event_metrics.py b/demos/smart_classroom_demo/utils/action_event_metrics.py
@@ -166,7 +166,7 @@ def match_detections(predicted_data, gt_data, min_iou):
         sorted_predicted_bboxes.sort(key=lambda tup: tup[1].det_conf, reverse=True)
 
         matches = []
-        visited_gt = np.zeros(len(gt_bboxes), dtype=np.bool)
+        visited_gt = np.zeros(len(gt_bboxes), dtype=bool)
         for i in range(len(sorted_predicted_bboxes)):
             predicted_id = sorted_predicted_bboxes[i][0]
             predicted_bbox = sorted_predicted_bboxes[i][1]
@@ -453,8 +453,8 @@ def calculate_metrics(all_tracks):
         total_num_gt_events += len(gt_events)
 
         if len(matches) > 0:
-            matched_gt = np.zeros([len(gt_events)], dtype=np.bool)
-            matched_pred = np.zeros([len(pred_events)], dtype=np.bool)
+            matched_gt = np.zeros([len(gt_events)], dtype=bool)
+            matched_pred = np.zeros([len(pred_events)], dtype=bool)
             for match in matches:
                 matched_gt[match[0]] = True
                 matched_pred[match[1]] = True
diff --git a/demos/text_to_speech_demo/python/utils/wav_processing.py b/demos/text_to_speech_demo/python/utils/wav_processing.py
@@ -28,7 +28,7 @@ def pad_tensor(x, pad, side='both'):
     # i.e., it won't generalise to other shapes/dims
     b, t, c = x.shape
     total = t + 2 * pad if side == 'both' else t + pad
-    padded = np.zeros((b, total, c), dtype=np.float)
+    padded = np.zeros((b, total, c), dtype=float)
     if side in ('before', 'both'):
         padded[:, pad:pad + t, :] = x
     elif side == 'after':
@@ -94,7 +94,7 @@ def fold_with_overlap(x, target, overlap):
         padding = target + 2 * overlap - remaining
         x = pad_tensor(x, padding, side='after')
 
-    folded = np.zeros((num_folds, target + 2 * overlap, features), dtype=np.float)
+    folded = np.zeros((num_folds, target + 2 * overlap, features), dtype=float)
 
 
     # Get the values for the folded tensor
@@ -113,13 +113,13 @@ def xfade_and_unfold(y, overlap):
     Args:
         y (ndarry)    : Batched sequences of audio samples
                         shape=(num_folds, target + 2 * overlap)
-                        dtype=np.float64
+                        dtype=float
         overlap (int) : Timesteps for both xfade and rnn warmup
 
     Return:
         (ndarry) : audio samples in a 1d array
                    shape=(total_len)
-                   dtype=np.float64
+                   dtype=float
 
     Details:
         y = [[seq1],
diff --git a/models/public/quartznet-15x5-en/model.yml b/models/public/quartznet-15x5-en/model.yml
@@ -101,7 +101,7 @@ conversion_to_onnx_args:
   - --model-param=decoder_weights=r"$dl_dir/models/.nemo_tmp/JasperDecoderForCTC.pt"
   - --input-names=audio_signal
   - --output-names=output
-  - '--conversion-param=dynamic_axes={"audio_signal": {0: "batch_size, 2: "wave_len"}, {"output: {0: "batch_size", 2: "wave_len"}}'
+  - '--conversion-param=dynamic_axes={"audio_signal": {0: "batch_size", 2: "wave_len"}, {"output": {0: "batch_size", 2: "wave_len"}}'
 input_info:
   - name: audio_signal
     shape: [1, 64, 128]
diff --git a/tools/accuracy_checker/openvino/tools/accuracy_checker/adapters/ctpn.py b/tools/accuracy_checker/openvino/tools/accuracy_checker/adapters/ctpn.py
@@ -329,7 +329,7 @@ def build_graph(self, text_proposals, scores, im_size):
             boxes_table[int(box[0])].append(index)
         self.boxes_table = boxes_table
 
-        graph = np.zeros((text_proposals.shape[0], text_proposals.shape[0]), np.bool)
+        graph = np.zeros((text_proposals.shape[0], text_proposals.shape[0]), bool)
 
         for index, box in enumerate(text_proposals):
             successions = self.get_successions(index)
@@ -381,7 +381,7 @@ def fit_y(x, y, x1, x2):
         text_lines[:, :4].clip(min=0, max=(im_size[1] - 1, im_size[0] - 1, im_size[1] - 1, im_size[0] - 1),
                                out=text_lines[:, :4])
 
-        text_recs = np.zeros((len(text_lines), 9), np.float)
+        text_recs = np.zeros((len(text_lines), 9), float)
         for index, line in enumerate(text_lines):
             xmin, ymin, xmax, ymax = line[0], line[1], line[2], line[3]
             text_recs[index, 0], text_recs[index, 1], text_recs[index, 2], text_recs[index, 3] = xmin, ymin, xmax, ymin
diff --git a/tools/accuracy_checker/openvino/tools/accuracy_checker/adapters/kaldi_asr_decoder.py b/tools/accuracy_checker/openvino/tools/accuracy_checker/adapters/kaldi_asr_decoder.py
@@ -187,7 +187,12 @@ def _dump_as_binary(out_file):
             with out_file.open('wb') as fd:
                 fd.write(str.encode(utterance_key + " "))
                 fd.write(str.encode('\0B'))
-                if mat.dtype not in [np.float32, np.float64]:
+                try:
+                    float64 = np.float64
+                except:
+                    float64 = float
+
+                if mat.dtype not in [np.float32, float64]:
                     raise RuntimeError("Unsupported numpy dtype: {}".format(mat.dtype))
                 mat_type = 'FM' if mat.dtype == np.float32 else 'DM'
                 fd.write(str.encode(mat_type + " "))
diff --git a/tools/accuracy_checker/openvino/tools/accuracy_checker/evaluators/custom_evaluators/opennmt_encoder_decoder_generator_evaluator.py b/tools/accuracy_checker/openvino/tools/accuracy_checker/evaluators/custom_evaluators/opennmt_encoder_decoder_generator_evaluator.py
@@ -292,11 +292,11 @@ def __init__(self, config):
 
         self.alive_seq = np.full([self.batch_size * self.beam_size, 1], self.bos, dtype=np.long)
         self.is_finished = np.zeros((self.batch_size, self.beam_size), dtype=np.uint8)
-        self.best_scores = np.full([self.batch_size], -1e10, dtype=np.float)
+        self.best_scores = np.full([self.batch_size], -1e10, dtype=float)
         self._beam_offset = np.arange(0, self.batch_size * self.beam_size, step=self.beam_size, dtype=np.long)
         self.topk_log_probs = np.asarray([0.0] + [float("-inf")] * (self.beam_size - 1))
         self.topk_log_probs = self.topk_log_probs.repeat(self.batch_size).reshape(self.batch_size, self.beam_size)
-        self.topk_scores = np.empty((self.batch_size, self.beam_size), dtype=np.float)
+        self.topk_scores = np.empty((self.batch_size, self.beam_size), dtype=float)
         self.topk_ids = np.empty((self.batch_size, self.beam_size), dtype=np.long)
         self._batch_index = np.empty([self.batch_size, self.beam_size], dtype=np.long)
 
diff --git a/tools/accuracy_checker/openvino/tools/accuracy_checker/metrics/detection.py b/tools/accuracy_checker/openvino/tools/accuracy_checker/metrics/detection.py
@@ -137,8 +137,8 @@ def per_class_detection_statistics(self, annotations, predictions, labels, profi
             tp, fp = np.cumsum(tp)[threshold_indexes], np.cumsum(fp)[threshold_indexes]
 
             labels_stat[label] = {
-                'precision': tp / np.maximum(tp + fp, np.finfo(np.float64).eps),
-                'recall': tp / np.maximum(n, np.finfo(np.float64).eps),
+                'precision': tp / np.maximum(tp + fp, np.finfo(float).eps),
+                'recall': tp / np.maximum(n, np.finfo(float).eps),
                 'thresholds': conf[threshold_indexes],
                 'fppi': fp / len(annotations),
                 'fp': np.sum(fp),
@@ -533,7 +533,7 @@ def match_detections_class_agnostic(prediction, gt, min_iou, overlap_method):
     similarity_matrix = calculate_similarity_matrix(predicted_bboxes, gt_bboxes, overlap_method)
 
     matches = []
-    visited_gt = np.zeros(gt_bboxes_num, dtype=np.bool)
+    visited_gt = np.zeros(gt_bboxes_num, dtype=bool)
     for predicted_id in range(predicted_bboxes_num):
         best_overlap = 0.0
         best_gt_id = -1
diff --git a/tools/accuracy_checker/openvino/tools/accuracy_checker/metrics/image_quality_assessment.py b/tools/accuracy_checker/openvino/tools/accuracy_checker/metrics/image_quality_assessment.py
@@ -163,8 +163,8 @@ def configure(self):
         self.block_size = self.get_value_from_config('block_size')
 
     def _psnr_differ(self, annotation_image, prediction_image):
-        prediction = np.asarray(prediction_image).astype(np.float)
-        ground_truth = np.asarray(annotation_image).astype(np.float)
+        prediction = np.asarray(prediction_image).astype(float)
+        ground_truth = np.asarray(annotation_image).astype(float)
 
         height, width = prediction.shape[:2]
         prediction = prediction[
diff --git a/tools/accuracy_checker/openvino/tools/accuracy_checker/metrics/multilabel_recognition.py b/tools/accuracy_checker/openvino/tools/accuracy_checker/metrics/multilabel_recognition.py
@@ -48,19 +48,19 @@ def configure(self):
             raise ConfigError('multi label metrics require label_map providing in dataset_meta'
                               'Please provide dataset meta file or regenerate annotation')
         self.calculate_average = self.get_value_from_config('calculate_average')
-        self.tp = np.zeros_like(list(self.labels.keys()), dtype=np.float)
-        self.fp = np.zeros_like(list(self.labels.keys()), dtype=np.float)
-        self.tn = np.zeros_like(list(self.labels.keys()), dtype=np.float)
-        self.fn = np.zeros_like(list(self.labels.keys()), dtype=np.float)
-        self.counter = np.zeros_like(list(self.labels.keys()), dtype=np.float)
+        self.tp = np.zeros_like(list(self.labels.keys()), dtype=float)
+        self.fp = np.zeros_like(list(self.labels.keys()), dtype=float)
+        self.tn = np.zeros_like(list(self.labels.keys()), dtype=float)
+        self.fn = np.zeros_like(list(self.labels.keys()), dtype=float)
+        self.counter = np.zeros_like(list(self.labels.keys()), dtype=float)
         self._create_meta()
 
     def update(self, annotation, prediction):
         def loss(annotation_labels, prediction_labels):
-            tp_result = np.zeros_like(list(self.labels.keys()), dtype=np.float)
-            fp_results = np.zeros_like(list(self.labels.keys()), dtype=np.float)
-            tn_results = np.zeros_like(list(self.labels.keys()), dtype=np.float)
-            fn_results = np.zeros_like(list(self.labels.keys()), dtype=np.float)
+            tp_result = np.zeros_like(list(self.labels.keys()), dtype=float)
+            fp_results = np.zeros_like(list(self.labels.keys()), dtype=float)
+            tn_results = np.zeros_like(list(self.labels.keys()), dtype=float)
+            fn_results = np.zeros_like(list(self.labels.keys()), dtype=float)
 
             for index, label in enumerate(annotation_labels):
                 if label == 1 and label == prediction_labels[index]:
@@ -106,11 +106,11 @@ def _create_meta(self):
             self.meta['names'].append('average')
 
     def reset(self):
-        self.tp = np.zeros_like(list(self.labels.keys()), dtype=np.float)
-        self.fp = np.zeros_like(list(self.labels.keys()), dtype=np.float)
-        self.tn = np.zeros_like(list(self.labels.keys()), dtype=np.float)
-        self.fn = np.zeros_like(list(self.labels.keys()), dtype=np.float)
-        self.counter = np.zeros_like(list(self.labels.keys()), dtype=np.float)
+        self.tp = np.zeros_like(list(self.labels.keys()), dtype=float)
+        self.fp = np.zeros_like(list(self.labels.keys()), dtype=float)
+        self.tn = np.zeros_like(list(self.labels.keys()), dtype=float)
+        self.fn = np.zeros_like(list(self.labels.keys()), dtype=float)
+        self.counter = np.zeros_like(list(self.labels.keys()), dtype=float)
         self._create_meta()
 
     @classmethod
diff --git a/tools/accuracy_checker/openvino/tools/accuracy_checker/metrics/regression.py b/tools/accuracy_checker/openvino/tools/accuracy_checker/metrics/regression.py
@@ -409,7 +409,7 @@ def update(self, annotation, prediction):
         result = point_regression_differ(
             annotation.x_values, annotation.y_values, prediction.x_values, prediction.y_values
         )
-        result /= np.maximum(annotation.normalization_coefficient, np.finfo(np.float64).eps)
+        result /= np.maximum(annotation.normalization_coefficient, np.finfo(float).eps)
         self.magnitude.append(result)
         if self.profiler:
             self.profiler.update(
diff --git a/tools/accuracy_checker/openvino/tools/accuracy_checker/metrics/reid.py b/tools/accuracy_checker/openvino/tools/accuracy_checker/metrics/reid.py
@@ -68,7 +68,7 @@ def _binary_clf_curve(y_true, y_score):
     threshold_idxs = np.r_[distinct_value_indices, y_true.size - 1]
 
     # accumulate the true positives with decreasing threshold
-    tps = np.cumsum((y_true * weight), axis=None, dtype=np.float64)[threshold_idxs]
+    tps = np.cumsum((y_true * weight), axis=None, dtype=float)[threshold_idxs]
     fps = 1 + threshold_idxs - tps
     return fps, tps, y_score[threshold_idxs]
 
@@ -563,7 +563,7 @@ def distance_matrix(annotation, prediction):
 
 
 def unique_sample(ids_dict, num):
-    mask = np.zeros(num, dtype=np.bool)
+    mask = np.zeros(num, dtype=bool)
     for indices in ids_dict.values():
         mask[np.random.choice(indices)] = True
 
diff --git a/tools/accuracy_checker/openvino/tools/accuracy_checker/postprocessor/filter.py b/tools/accuracy_checker/openvino/tools/accuracy_checker/postprocessor/filter.py
@@ -299,7 +299,7 @@ def apply_filter(self, entry, filter_arg):
         filtered = []
         coordinates = zip(entry.x_mins, entry.y_mins, entry.x_maxs, entry.y_maxs)
         for index, (x_min, y_min, x_max, y_max) in enumerate(coordinates):
-            ratio = (y_max - y_min) / np.maximum(x_max - x_min, np.finfo(np.float64).eps)
+            ratio = (y_max - y_min) / np.maximum(x_max - x_min, np.finfo(float).eps)
             if not in_interval(ratio, aspect_ratio):
                 filtered.append(index)
 
diff --git a/tools/accuracy_checker/openvino/tools/accuracy_checker/postprocessor/normalize_boxes.py b/tools/accuracy_checker/openvino/tools/accuracy_checker/postprocessor/normalize_boxes.py
@@ -48,9 +48,9 @@ def configure(self):
     def process_image(self, annotation, prediction):
         height, width, _ = self.image_size
         for target in annotation:
-            target.x_mins /= np.maximum(float(width), np.finfo(np.float64).eps)
-            target.x_maxs /= np.maximum(float(width), np.finfo(np.float64).eps)
-            target.y_mins /= np.maximum(float(height), np.finfo(np.float64).eps)
-            target.y_maxs /= np.maximum(float(height), np.finfo(np.float64).eps)
+            target.x_mins /= np.maximum(float(width), np.finfo(float).eps)
+            target.x_maxs /= np.maximum(float(width), np.finfo(float).eps)
+            target.y_mins /= np.maximum(float(height), np.finfo(float).eps)
+            target.y_maxs /= np.maximum(float(height), np.finfo(float).eps)
 
         return annotation, prediction
diff --git a/tools/accuracy_checker/openvino/tools/accuracy_checker/postprocessor/normalize_landmarks_points.py b/tools/accuracy_checker/openvino/tools/accuracy_checker/postprocessor/normalize_landmarks_points.py
@@ -54,10 +54,10 @@ def process_image(self, annotation, prediction):
                 height = y_max - y_start
 
             target.x_values = (
-                (np.array(target.x_values, dtype=float) - x_start) / np.maximum(width, np.finfo(np.float64).eps)
+                (np.array(target.x_values, dtype=float) - x_start) / np.maximum(width, np.finfo(float).eps)
             )
             target.y_values = (
-                (np.array(target.y_values, dtype=float) - y_start) / np.maximum(height, np.finfo(np.float64).eps)
+                (np.array(target.y_values, dtype=float) - y_start) / np.maximum(height, np.finfo(float).eps)
             )
 
         return annotation, prediction
diff --git a/tools/accuracy_checker/openvino/tools/accuracy_checker/preprocessor/geometric_transformations.py b/tools/accuracy_checker/openvino/tools/accuracy_checker/preprocessor/geometric_transformations.py
@@ -84,7 +84,7 @@ class PointAligner(Preprocessor):
         48.0252 / 96, 71.7366 / 112,
         33.5493 / 96, 92.3655 / 112,
         62.7299 / 96, 92.2041 / 112
-    ], dtype=np.float64).reshape(5, 2)
+    ], dtype=float).reshape(5, 2)
 
     @classmethod
     def parameters(cls):
@@ -138,11 +138,11 @@ def align(self, img, points):
         if self.normalize:
             inp_shape = img.shape
 
-        keypoints = points.copy().astype(np.float64)
+        keypoints = points.copy().astype(float)
         keypoints[:, 0] *= (float(self.dst_width) / inp_shape[1])
         keypoints[:, 1] *= (float(self.dst_height) / inp_shape[0])
 
-        keypoints_ref = np.zeros((points_number, 2), dtype=np.float64)
+        keypoints_ref = np.zeros((points_number, 2), dtype=float)
         keypoints_ref[:, 0] = self.ref_landmarks[:, 0] * self.dst_width
         keypoints_ref[:, 1] = self.ref_landmarks[:, 1] * self.dst_height
 
@@ -156,18 +156,18 @@ def align(self, img, points):
 
     @staticmethod
     def transformation_from_points(points1, points2):
-        points1 = points1.astype(np.float64)
-        points2 = points2.astype(np.float64)
+        points1 = points1.astype(float)
+        points2 = points2.astype(float)
 
         c1 = np.mean(points1, axis=0, keepdims=True)
         c2 = np.mean(points2, axis=0, keepdims=True)
         points1 -= c1
         points2 -= c2
         s1 = np.std(points1)
         s2 = np.std(points2)
-        points1 /= np.maximum(s1, np.finfo(np.float64).eps)
-        points2 /= np.maximum(s1, np.finfo(np.float64).eps)
-        points_std_ratio = s2 / np.maximum(s1, np.finfo(np.float64).eps)
+        points1 /= np.maximum(s1, np.finfo(float).eps)
+        points2 /= np.maximum(s1, np.finfo(float).eps)
+        points_std_ratio = s2 / np.maximum(s1, np.finfo(float).eps)
 
         u, _, vt = np.linalg.svd(points1.T @ points2)
         r = (u @ vt).T
