Reduce the number of C++ warnings.

Author: sdpython

_unittests/ut_sklapi/test_onnx_pipeline.py

@@ -171,8 +171,8 @@ def test_pipeline_pickable_options(self):
         sess = OnnxInference(model_def)
         res = sess.run({'X': X})
         self.assertEqual(list(sorted(res)), ['label', 'probabilities'])
-        self.assertEqualArray(res["label"], pipe.predict(X))
         self.assertEqualArray(res["probabilities"], pipe.predict_proba(X))
+        self.assertEqualArray(res["label"], pipe.predict(X))
 
     def test_pipeline_iris_column_transformer(self):
         iris = load_iris()
@@ -243,5 +243,5 @@ def cache(self, obj):
 
 
 if __name__ == '__main__':
-    TestOnnxPipeline().test_pipeline_none_params()
+    # TestOnnxPipeline().test_pipeline_pickable_options()
     unittest.main()

mlprodict/onnxrt/ops_cpu/op_conv_transpose_.cpp

@@ -140,9 +140,9 @@ py::array_t<T> ConvTranspose<T>::compute(py::array_t<T, py::array::c_style | py:
     std::vector<int64_t> w_dims;
     arrayshape2vector(w_dims, W);
 
-    const int64_t N = x_dims[0];
+    // const int64_t N = x_dims[0];
     // const int64_t C = x_dims[1];
-    const int64_t M = w_dims[1];
+    // const int64_t M = w_dims[1];
 
     std::vector<int64_t> input_shape(x_dims.begin() + 2, x_dims.end());
 
@@ -256,13 +256,13 @@ void ConvTranspose<T>::compute_gil_free(
 
     const int64_t N = x_dims[0];
     const int64_t C = x_dims[1];
-    const int64_t num_input_channels = C;
+    // const int64_t num_input_channels = C;
     const int64_t num_output_channels = w_dims[1] * group_;
     const int64_t M = w_dims[0];
 
     const int64_t input_shape_size = flattened_dimension(input_shape);
     const int64_t output_image_size = flattened_dimension(y_dims, 2);
-    const int64_t output_shape_size = flattened_dimension(output_shape);
+    // const int64_t output_shape_size = flattened_dimension(output_shape);
     const int64_t y_size = flattened_dimension(y_dims);
     const int64_t kernel_size = flattened_dimension(kernel_shape);
     const int64_t X_offset = C / group_ * input_shape_size;
@@ -286,7 +286,7 @@ void ConvTranspose<T>::compute_gil_free(
 
     std::fill(Ydata, Ydata + y_size, (T)0);
 
-    const size_t kernel_rank = kernel_shape.size();
+    // const size_t kernel_rank = kernel_shape.size();
 
     std::vector<int64_t> output_shape2(y_dims.begin() + 1, y_dims.end());
     output_shape2[0] /= group_;

mlprodict/onnxrt/ops_cpu/op_gather_.cpp

@@ -115,7 +115,7 @@ void GatherCopyData(const py::array_t<int64_t, py::array::c_style | py::array::f
         int64_t idx = indices_data[i];
         if (idx < -axis_dim_limit || idx >= axis_dim_limit) {
             char buffer[1000];
-            sprintf(buffer, "Indices element out of data bounds, idx=%d  must be within the inclusive range [%d,%d]",
+            sprintf(buffer, "Indices element out of data bounds, idx=%ld  must be within the inclusive range [%ld,%ld]",
                     idx, -axis_dim_limit, axis_dim_limit-1);
         }
     }

mlprodict/onnxrt/ops_cpu/op_tfidfvectorizer_.cpp

@@ -213,7 +213,7 @@ void RuntimeTfIdfVectorizer::Init(
         auto items = end_idx - start_idx;
         if (items > 0) {
             auto ngrams = items / ngram_size;
-            if (ngram_size >= min_gram_length && ngram_size <= max_gram_length)
+            if ((int)ngram_size >= min_gram_length && (int)ngram_size <= max_gram_length)
                 ngram_id = PopulateGrams<int64_t>(
                     pool_int64s.begin() + start_idx, ngrams, ngram_size,
                     ngram_id, int64_map_);

mlprodict/onnxrt/ops_cpu/op_tree_ensemble_common_p_.hpp

@@ -667,7 +667,9 @@ void RuntimeTreeEnsembleCommonP<NTYPE>::compute_gil_free(
                     &has_scores[th * n_targets_or_classes_]);
             }
 
-            for (size_t th = 1; th < nth; ++th) {
+            if (nth <= 0)
+                throw std::runtime_error("nth must strictly positive.");
+            for (size_t th = 1; th < (size_t)nth; ++th) {
                 agg.MergePrediction(n_targets_or_classes_,
                     scores.data(), has_scores.data(),
                     &scores[th * n_targets_or_classes_],
@@ -897,6 +899,9 @@ void RuntimeTreeEnsembleCommonP<NTYPE>::compute_gil_free_array_structure(
         }
         else if (para_tree_ && (omp_get_max_threads() > 1) && (n_trees_ > omp_tree_)) { DEBUGPRINT("T")
             auto nth = omp_get_max_threads();
+            if (nth <= 0)
+                throw std::runtime_error("nth must strictly positive.");
+            
             auto size_obs = N * n_targets_or_classes_;
             std::vector<NTYPE> local_scores(nth * size_obs, 0);
             std::vector<unsigned char> local_has_scores(local_scores.size(), 0);
@@ -929,7 +934,7 @@ void RuntimeTreeEnsembleCommonP<NTYPE>::compute_gil_free_array_structure(
                 unsigned char* p_has_score = &local_has_scores[i * n_targets_or_classes_];
                 NTYPE* pp_score = p_score + size_obs;
                 unsigned char* pp_has_score = p_has_score + size_obs;
-                for (size_t j = 1; j < nth; ++j, pp_score += size_obs, pp_has_score += size_obs) {
+                for (size_t j = 1; j < (size_t)nth; ++j, pp_score += size_obs, pp_has_score += size_obs) {
                     agg.MergePrediction(
                         n_targets_or_classes_, 
                         p_score, p_has_score, pp_score, pp_has_score);