MNT: replace usage of regression_coverage_score by regression_coverage_score_v2 everywhere except doc examples and notebooks

Author: Valentin-Laurent

doc/api.rst

@@ -92,7 +92,6 @@ Regression Metrics
    :toctree: generated/
    :template: function.rst
 
-   mapie.metrics.regression.regression_coverage_score
    mapie.metrics.regression.regression_coverage_score_v2
    mapie.metrics.regression.regression_mean_width_score
    mapie.metrics.regression.regression_ssc

mapie/metrics/regression.py

@@ -542,11 +542,10 @@ def coverage_width_based(
 
     check_alpha(1-alpha)
 
-    coverage_score = regression_coverage_score(
+    coverage_score = regression_coverage_score_v2(
         y_true,
-        y_pred_low,
-        y_pred_up
-    )
+        np.column_stack((y_pred_low, y_pred_up)),
+    )[0]
     mean_width = regression_mean_width_score(
         y_pred_low,
         y_pred_up

mapie/tests/test_metrics.py

@@ -32,7 +32,6 @@
     classification_ssc, classification_ssc_score,
 )
 from mapie.metrics.regression import (
-    regression_coverage_score,
     regression_mean_width_score,
     regression_coverage_score_v2,
     regression_ssc,
@@ -194,8 +193,6 @@
 
 def test_regression_ypredlow_shape() -> None:
     """Test shape of y_pred_low."""
-    with pytest.raises(ValueError, match=r".*y should be a 1d array*"):
-        regression_coverage_score(y_toy, y_preds[:, :2], y_preds[:, 2])
     with pytest.raises(ValueError, match=r".*y should be a 1d array*"):
         regression_mean_width_score(y_preds[:, :2], y_preds[:, 2])
     with pytest.raises(ValueError):
@@ -206,8 +203,6 @@ def test_regression_ypredlow_shape() -> None:
 
 def test_regression_ypredup_shape() -> None:
     """Test shape of y_pred_up."""
-    with pytest.raises(ValueError, match=r".*y should be a 1d array*"):
-        regression_coverage_score(y_toy, y_preds[:, 1], y_preds[:, 1:])
     with pytest.raises(ValueError, match=r".*y should be a 1d array*"):
         regression_mean_width_score(y_preds[:, :2], y_preds[:, 2])
     with pytest.raises(ValueError):
@@ -251,8 +246,6 @@ def test_regression_valid_input_shape() -> None:
 
 def test_regression_same_length() -> None:
     """Test when y_true and y_preds have different lengths."""
-    with pytest.raises(ValueError, match=r".*arrays with different len*"):
-        regression_coverage_score(y_toy, y_preds[:-1, 1], y_preds[:-1, 2])
     with pytest.raises(ValueError, match=r".*y should be a 1d array*"):
         regression_mean_width_score(y_preds[:, :2], y_preds[:, 2])
     with pytest.raises(ValueError, match=r".*shape mismatch*"):
@@ -269,25 +262,7 @@ def test_regression_same_length() -> None:
 
 def test_regression_toydata_coverage_score() -> None:
     """Test coverage_score for toy data."""
-    scr = regression_coverage_score(y_toy, y_preds[:, 1], y_preds[:, 2])
-    assert scr == 0.8
-
-
-def test_regression_ytrue_type_coverage_score() -> None:
-    """Test that list(y_true) gives right coverage."""
-    scr = regression_coverage_score(list(y_toy), y_preds[:, 1], y_preds[:, 2])
-    assert scr == 0.8
-
-
-def test_regression_ypredlow_type_coverage_score() -> None:
-    """Test that list(y_pred_low) gives right coverage."""
-    scr = regression_coverage_score(y_toy, list(y_preds[:, 1]), y_preds[:, 2])
-    assert scr == 0.8
-
-
-def test_regression_ypredup_type_coverage_score() -> None:
-    """Test that list(y_pred_up) gives right coverage."""
-    scr = regression_coverage_score(y_toy, y_preds[:, 1], list(y_preds[:, 2]))
+    scr = regression_coverage_score_v2(y_toy, y_preds[:, 1:])[0]
     assert scr == 0.8
 
 
@@ -582,18 +557,6 @@ def test_hsic_correlation_value() -> None:
     np.testing.assert_allclose(coef, np.array([0.16829506, 0.3052798]))
 
 
-def test_regression_coverage_v1andv2() -> None:
-    """
-    Test that ``regression_coverage_score`` and
-    ```regression_coverage_score_v2``` returns the same results
-    """
-    cov_v1 = regression_coverage_score(
-        y_toy, intervals[:, 0, 0], intervals[:, 1, 0]
-    )
-    cov_v2 = regression_coverage_score_v2(np.expand_dims(y_toy, 1), intervals)
-    np.testing.assert_allclose(cov_v1, cov_v2[0])
-
-
 def test_regression_coverage_score_v2_ytrue_valid_shape() -> None:
     """Test that no error is raised if y_true has the shape (n_samples,)."""
     regression_coverage_score_v2(y_toy, intervals)

mapie/tests/test_quantile_regression.py

@@ -19,7 +19,9 @@
 from typing_extensions import TypedDict
 
 from numpy.typing import NDArray
-from mapie.metrics.regression import regression_coverage_score
+from mapie.metrics.regression import (
+    regression_coverage_score_v2,
+)
 from mapie.regression import MapieQuantileRegressor
 
 X_toy = np.array(
@@ -514,7 +516,7 @@ def test_linear_regression_results(strategy: str) -> None:
     _, y_pis = mapie.predict(X)
     y_pred_low, y_pred_up = y_pis[:, 0, 0], y_pis[:, 1, 0]
     width_mean = (y_pred_up - y_pred_low).mean()
-    coverage = regression_coverage_score(y, y_pred_low, y_pred_up)
+    coverage = regression_coverage_score_v2(y, y_pis)[0]
     np.testing.assert_allclose(width_mean, WIDTHS[strategy], rtol=1e-2)
     np.testing.assert_allclose(coverage, COVERAGES[strategy], rtol=1e-2)
 

mapie/tests/test_regression.py

@@ -31,7 +31,9 @@
     ResidualNormalisedScore
 )
 from mapie.estimator.regressor import EnsembleRegressor
-from mapie.metrics.regression import regression_coverage_score
+from mapie.metrics.regression import (
+    regression_coverage_score_v2,
+)
 from mapie.regression import MapieRegressor
 from mapie.subsample import Subsample
 
@@ -312,8 +314,7 @@ def test_coverage_validity(delta: float, n_calib: int) -> None:
         Xc, Xt, yc, yt = train_test_split(Xct, yct, test_size=n_test)
         mapie_reg.fit(Xc, yc)
         _, y_pis = mapie_reg.predict(Xt, alpha=1-delta)
-        y_low, y_up = y_pis[:, 0, 0], y_pis[:, 1, 0]
-        coverage = regression_coverage_score(yt, y_low, y_up)
+        coverage = regression_coverage_score_v2(yt, y_pis)[0]
         cov_list.append(coverage)
 
     # Here we are testing whether the average coverage is statistically
@@ -620,7 +621,7 @@ def test_linear_regression_results(strategy: str) -> None:
     _, y_pis = mapie.predict(X, alpha=0.05)
     y_pred_low, y_pred_up = y_pis[:, 0, 0], y_pis[:, 1, 0]
     width_mean = (y_pred_up - y_pred_low).mean()
-    coverage = regression_coverage_score(y, y_pred_low, y_pred_up)
+    coverage = regression_coverage_score_v2(y, y_pis)[0]
     np.testing.assert_allclose(width_mean, WIDTHS[strategy], rtol=1e-2)
     np.testing.assert_allclose(coverage, COVERAGES[strategy], rtol=1e-2)
 
@@ -650,7 +651,7 @@ def test_results_prefit_naive() -> None:
     mapie_reg.fit(X, y)
     _, y_pis = mapie_reg.predict(X, alpha=0.05)
     width_mean = (y_pis[:, 1, 0] - y_pis[:, 0, 0]).mean()
-    coverage = regression_coverage_score(y, y_pis[:, 0, 0], y_pis[:, 1, 0])
+    coverage = regression_coverage_score_v2(y, y_pis)[0]
     np.testing.assert_allclose(width_mean, WIDTHS["naive"], rtol=1e-2)
     np.testing.assert_allclose(coverage, COVERAGES["naive"], rtol=1e-2)
 
@@ -665,9 +666,7 @@ def test_results_prefit() -> None:
     mapie_reg.fit(X_calib, y_calib)
     _, y_pis = mapie_reg.predict(X_calib, alpha=0.05)
     width_mean = (y_pis[:, 1, 0] - y_pis[:, 0, 0]).mean()
-    coverage = regression_coverage_score(
-        y_calib, y_pis[:, 0, 0], y_pis[:, 1, 0]
-    )
+    coverage = regression_coverage_score_v2(y_calib, y_pis)[0]
     np.testing.assert_allclose(width_mean, WIDTHS["prefit"], rtol=1e-2)
     np.testing.assert_allclose(coverage, COVERAGES["prefit"], rtol=1e-2)
 

mapie/tests/test_time_series_regression.py

@@ -13,7 +13,9 @@
 from numpy.typing import NDArray
 from mapie.aggregation_functions import aggregate_all
 from mapie.conformity_scores import AbsoluteConformityScore
-from mapie.metrics.regression import regression_coverage_score
+from mapie.metrics.regression import (
+    regression_coverage_score_v2,
+)
 from mapie.regression import MapieTimeSeriesRegressor
 from mapie.subsample import BlockBootstrap
 
@@ -284,7 +286,7 @@ def test_linear_regression_results(strategy: str) -> None:
     y_pred_low, y_pred_up = y_pis[:, 0, 0], y_pis[:, 1, 0]
     width_mean = (y_pred_up - y_pred_low).mean()
 
-    coverage = regression_coverage_score(y, y_pred_low, y_pred_up)
+    coverage = regression_coverage_score_v2(y, y_pis)[0]
     np.testing.assert_allclose(width_mean, WIDTHS[strategy], rtol=1e-2)
     np.testing.assert_allclose(coverage, COVERAGES[strategy], rtol=1e-2)
 
@@ -304,9 +306,7 @@ def test_results_prefit() -> None:
     mapie_ts_reg.fit(X_val, y_val)
     _, y_pis = mapie_ts_reg.predict(X_test, alpha=0.05)
     width_mean = (y_pis[:, 1, 0] - y_pis[:, 0, 0]).mean()
-    coverage = regression_coverage_score(
-        y_test, y_pis[:, 0, 0], y_pis[:, 1, 0]
-    )
+    coverage = regression_coverage_score_v2(y_test, y_pis)[0]
     np.testing.assert_allclose(width_mean, WIDTHS["prefit"], rtol=1e-2)
     np.testing.assert_allclose(coverage, COVERAGES["prefit"], rtol=1e-2)
 
@@ -423,9 +423,7 @@ def test_interval_prediction_with_beta_optimize() -> None:
     mapie_ts_reg.update(X_val, y_val)
     _, y_pis = mapie_ts_reg.predict(X_test, alpha=0.05, optimize_beta=True)
     width_mean = (y_pis[:, 1, 0] - y_pis[:, 0, 0]).mean()
-    coverage = regression_coverage_score(
-        y_test, y_pis[:, 0, 0], y_pis[:, 1, 0]
-    )
+    coverage = regression_coverage_score_v2(y_test, y_pis)[0]
     np.testing.assert_allclose(width_mean, 3.67, rtol=1e-2)
     np.testing.assert_allclose(coverage, 0.916, rtol=1e-2)